@mastra/clickhouse 0.0.0-vnext-inngest-20250508122351 → 0.0.0-vnext-20251104230439

package/dist/index.js

@@ -1,20 +1,19 @@
 import { createClient } from '@clickhouse/client';
-import { TABLE_EVALS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, MastraStorage, TABLE_SCHEMAS } from '@mastra/core/storage';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
+import { TABLE_AI_SPANS, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, MastraStorage, StoreOperations, TABLE_SCHEMAS, WorkflowsStorage, normalizePerPage, ScoresStorage, safelyParseJSON, calculatePagination, MemoryStorage, resolveMessageLimit } from '@mastra/core/storage';
+import { MessageList } from '@mastra/core/agent';
+import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // src/storage/index.ts
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
 var TABLE_ENGINES = {
   [TABLE_MESSAGES]: `MergeTree()`,
   [TABLE_WORKFLOW_SNAPSHOT]: `ReplacingMergeTree()`,
   [TABLE_TRACES]: `MergeTree()`,
   [TABLE_THREADS]: `ReplacingMergeTree()`,
-  [TABLE_EVALS]: `MergeTree()`
+  [TABLE_SCORERS]: `MergeTree()`,
+  [TABLE_RESOURCES]: `ReplacingMergeTree()`,
+  // TODO: verify this is the correct engine for ai spans when implementing clickhouse storage
+  [TABLE_AI_SPANS]: `ReplacingMergeTree()`
 };
 var COLUMN_TYPES = {
   text: "String",
@@ -22,11 +21,10 @@ var COLUMN_TYPES = {
   uuid: "String",
   jsonb: "String",
   integer: "Int64",
-  bigint: "Int64"
+  float: "Float64",
+  bigint: "Int64",
+  boolean: "Bool"
 };
-function transformRows(rows) {
-  return rows.map((row) => transformRow(row));
-}
 function transformRow(row) {
   if (!row) {
     return row;
@@ -37,54 +35,824 @@ function transformRow(row) {
   if (row.updatedAt) {
     row.updatedAt = new Date(row.updatedAt);
   }
+  if (row.content && typeof row.content === "string") {
+    row.content = safelyParseJSON(row.content);
+  }
   return row;
 }
-var ClickhouseStore = class extends MastraStorage {
-  db;
-  ttl = {};
-  constructor(config) {
-    super({ name: "ClickhouseStore" });
-    this.db = createClient({
-      url: config.url,
-      username: config.username,
-      password: config.password,
-      clickhouse_settings: {
-        date_time_input_format: "best_effort",
-        date_time_output_format: "iso",
-        // This is crucial
-        use_client_time_zone: 1,
-        output_format_json_quote_64bit_integers: 0
+function transformRows(rows) {
+  return rows.map((row) => transformRow(row));
+}
+
+// src/storage/domains/memory/index.ts
+var MemoryStorageClickhouse = class extends MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy
+  }) {
+    try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+      const messages = [];
+      const limit = resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      const include = selectBy?.include || [];
+      if (include.length) {
+        const unionQueries = [];
+        const params = [];
+        let paramIdx = 1;
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(`
+            SELECT * FROM (
+              WITH numbered_messages AS (
+                SELECT
+                  id, content, role, type, "createdAt", thread_id, "resourceId",
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                FROM "${TABLE_MESSAGES}"
+                WHERE thread_id = {var_thread_id_${paramIdx}:String}
+              ),
+              target_positions AS (
+                SELECT row_num as target_pos
+                FROM numbered_messages
+                WHERE id = {var_include_id_${paramIdx}:String}
+              )
+              SELECT DISTINCT m.id, m.content, m.role, m.type, m."createdAt", m.thread_id AS "threadId"
+              FROM numbered_messages m
+              CROSS JOIN target_positions t
+              WHERE m.row_num BETWEEN (t.target_pos - {var_withPreviousMessages_${paramIdx}:Int64}) AND (t.target_pos + {var_withNextMessages_${paramIdx}:Int64})
+            ) AS query_${paramIdx}
+          `);
+          params.push(
+            { [`var_thread_id_${paramIdx}`]: searchId },
+            { [`var_include_id_${paramIdx}`]: id },
+            { [`var_withPreviousMessages_${paramIdx}`]: withPreviousMessages },
+            { [`var_withNextMessages_${paramIdx}`]: withNextMessages }
+          );
+          paramIdx++;
+        }
+        const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" DESC';
+        const mergedParams = params.reduce((acc, paramObj) => ({ ...acc, ...paramObj }), {});
+        const includeResult = await this.client.query({
+          query: finalQuery,
+          query_params: mergedParams,
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            date_time_output_format: "iso",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        });
+        const rows2 = await includeResult.json();
+        const includedMessages = transformRows(rows2.data);
+        const seen = /* @__PURE__ */ new Set();
+        const dedupedMessages = includedMessages.filter((message) => {
+          if (seen.has(message.id)) return false;
+          seen.add(message.id);
+          return true;
+        });
+        messages.push(...dedupedMessages);
       }
-    });
-    this.ttl = config.ttl;
+      let whereClause = "WHERE thread_id = {threadId:String}";
+      const queryParams = {
+        threadId,
+        exclude: messages.map((m) => m.id),
+        limit
+      };
+      if (resourceId) {
+        whereClause += ' AND "resourceId" = {resourceId:String}';
+        queryParams.resourceId = resourceId;
+      }
+      const result = await this.client.query({
+        query: `
+        SELECT 
+            id, 
+            content, 
+            role, 
+            type,
+            toDateTime64(createdAt, 3) as createdAt,
+            thread_id AS "threadId"
+        FROM "${TABLE_MESSAGES}"
+        ${whereClause}
+        AND id NOT IN ({exclude:Array(String)})
+        ORDER BY "createdAt" DESC
+        LIMIT {limit:Int64}
+        `,
+        query_params: queryParams,
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await result.json();
+      messages.push(...transformRows(rows.data));
+      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      messages.forEach((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+      });
+      const list = new MessageList({ threadId, resourceId }).add(
+        messages,
+        "memory"
+      );
+      return { messages: list.get.all.db() };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error
+      );
+    }
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    try {
+      const result = await this.client.query({
+        query: `
+        SELECT 
+          id, 
+          content, 
+          role, 
+          type,
+          toDateTime64(createdAt, 3) as createdAt,
+          thread_id AS "threadId",
+          "resourceId"
+        FROM "${TABLE_MESSAGES}"
+        WHERE id IN {messageIds:Array(String)}
+        ORDER BY "createdAt" DESC
+        `,
+        query_params: {
+          messageIds
+        },
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await result.json();
+      const messages = transformRows(rows.data);
+      messages.forEach((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+      });
+      const list = new MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LIST_MESSAGES_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error
+      );
+    }
   }
-  transformEvalRow(row) {
-    row = transformRow(row);
-    const resultValue = JSON.parse(row.result);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
-    if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: "STORAGE_CLICKHOUSE_LIST_MESSAGES_INVALID_PAGE",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    if (!threadId.trim()) {
+      throw new MastraError(
+        {
+          id: "STORAGE_CLICKHOUSE_LIST_MESSAGES_INVALID_THREAD_ID",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        new Error("threadId must be a non-empty string")
+      );
+    }
+    const perPageForQuery = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPageForQuery);
+    try {
+      let dataQuery = `
+        SELECT 
+          id,
+          content,
+          role,
+          type,
+          toDateTime64(createdAt, 3) as createdAt,
+          thread_id AS "threadId",
+          resourceId
+        FROM ${TABLE_MESSAGES}
+        WHERE thread_id = {threadId:String}
+      `;
+      const dataParams = { threadId };
+      if (resourceId) {
+        dataQuery += ` AND resourceId = {resourceId:String}`;
+        dataParams.resourceId = resourceId;
+      }
+      if (filter?.dateRange?.start) {
+        const startDate = filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : new Date(filter.dateRange.start).toISOString();
+        dataQuery += ` AND createdAt >= parseDateTime64BestEffort({fromDate:String}, 3)`;
+        dataParams.fromDate = startDate;
+      }
+      if (filter?.dateRange?.end) {
+        const endDate = filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : new Date(filter.dateRange.end).toISOString();
+        dataQuery += ` AND createdAt <= parseDateTime64BestEffort({toDate:String}, 3)`;
+        dataParams.toDate = endDate;
+      }
+      const { field, direction } = this.parseOrderBy(orderBy);
+      dataQuery += ` ORDER BY "${field}" ${direction}`;
+      if (perPageForResponse === false) ; else {
+        dataQuery += ` LIMIT {limit:Int64} OFFSET {offset:Int64}`;
+        dataParams.limit = perPageForQuery;
+        dataParams.offset = offset;
+      }
+      const result = await this.client.query({
+        query: dataQuery,
+        query_params: dataParams,
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await result.json();
+      const paginatedMessages = transformRows(rows.data);
+      const paginatedCount = paginatedMessages.length;
+      let countQuery = `SELECT count() as total FROM ${TABLE_MESSAGES} WHERE thread_id = {threadId:String}`;
+      const countParams = { threadId };
+      if (resourceId) {
+        countQuery += ` AND resourceId = {resourceId:String}`;
+        countParams.resourceId = resourceId;
+      }
+      if (filter?.dateRange?.start) {
+        const startDate = filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : new Date(filter.dateRange.start).toISOString();
+        countQuery += ` AND createdAt >= parseDateTime64BestEffort({fromDate:String}, 3)`;
+        countParams.fromDate = startDate;
+      }
+      if (filter?.dateRange?.end) {
+        const endDate = filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : new Date(filter.dateRange.end).toISOString();
+        countQuery += ` AND createdAt <= parseDateTime64BestEffort({toDate:String}, 3)`;
+        countParams.toDate = endDate;
+      }
+      const countResult = await this.client.query({
+        query: countQuery,
+        query_params: countParams,
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const countData = await countResult.json();
+      const total = countData.data[0].total;
+      if (total === 0 && paginatedCount === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(paginatedMessages.map((m) => m.id));
+      let includeMessages = [];
+      if (include && include.length > 0) {
+        const unionQueries = [];
+        const params = [];
+        let paramIdx = 1;
+        for (const inc of include) {
+          const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+          const searchId = inc.threadId || threadId;
+          unionQueries.push(`
+            SELECT * FROM (
+              WITH numbered_messages AS (
+                SELECT
+                  id, content, role, type, "createdAt", thread_id, "resourceId",
+                  ROW_NUMBER() OVER (ORDER BY "createdAt" ASC) as row_num
+                FROM "${TABLE_MESSAGES}"
+                WHERE thread_id = {var_thread_id_${paramIdx}:String}
+              ),
+              target_positions AS (
+                SELECT row_num as target_pos
+                FROM numbered_messages
+                WHERE id = {var_include_id_${paramIdx}:String}
+              )
+              SELECT DISTINCT m.id, m.content, m.role, m.type, m."createdAt", m.thread_id AS "threadId", m."resourceId"
+              FROM numbered_messages m
+              CROSS JOIN target_positions t
+              WHERE m.row_num BETWEEN (t.target_pos - {var_withPreviousMessages_${paramIdx}:Int64}) AND (t.target_pos + {var_withNextMessages_${paramIdx}:Int64})
+            ) AS query_${paramIdx}
+          `);
+          params.push(
+            { [`var_thread_id_${paramIdx}`]: searchId },
+            { [`var_include_id_${paramIdx}`]: id },
+            { [`var_withPreviousMessages_${paramIdx}`]: withPreviousMessages },
+            { [`var_withNextMessages_${paramIdx}`]: withNextMessages }
+          );
+          paramIdx++;
+        }
+        const finalQuery = unionQueries.join(" UNION ALL ") + ' ORDER BY "createdAt" ASC';
+        const mergedParams = params.reduce((acc, paramObj) => ({ ...acc, ...paramObj }), {});
+        const includeResult = await this.client.query({
+          query: finalQuery,
+          query_params: mergedParams,
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            date_time_output_format: "iso",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        });
+        const includeRows = await includeResult.json();
+        includeMessages = transformRows(includeRows.data);
+        for (const includeMsg of includeMessages) {
+          if (!messageIds.has(includeMsg.id)) {
+            paginatedMessages.push(includeMsg);
+            messageIds.add(includeMsg.id);
+          }
+        }
+      }
+      const list = new MessageList().add(paginatedMessages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.sort((a, b) => {
+        const isDateField = field === "createdAt" || field === "updatedAt";
+        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+        if (aValue === bValue) {
+          return a.id.localeCompare(b.id);
+        }
+        if (typeof aValue === "number" && typeof bValue === "number") {
+          return direction === "ASC" ? aValue - bValue : bValue - aValue;
+        }
+        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+      });
+      const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
+      const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
+      const hasMore = perPageForResponse === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "STORAGE_CLICKHOUSE_STORE_LIST_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId,
+            resourceId: resourceId ?? ""
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
+  async saveMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) return { messages };
+    for (const message of messages) {
+      const resourceId = message.resourceId;
+      if (!resourceId) {
+        throw new Error("Resource ID is required");
+      }
+      if (!message.threadId) {
+        throw new Error("Thread ID is required");
+      }
+      const thread = await this.getThreadById({ threadId: message.threadId });
+      if (!thread) {
+        throw new Error(`Thread ${message.threadId} not found`);
+      }
+    }
+    const threadIdSet = /* @__PURE__ */ new Map();
+    await Promise.all(
+      messages.map(async (m) => {
+        const resourceId = m.resourceId;
+        if (!resourceId) {
+          throw new Error("Resource ID is required");
+        }
+        if (!m.threadId) {
+          throw new Error("Thread ID is required");
+        }
+        const thread = await this.getThreadById({ threadId: m.threadId });
+        if (!thread) {
+          throw new Error(`Thread ${m.threadId} not found`);
+        }
+        threadIdSet.set(m.threadId, thread);
+      })
+    );
+    try {
+      const existingResult = await this.client.query({
+        query: `SELECT id, thread_id FROM ${TABLE_MESSAGES} WHERE id IN ({ids:Array(String)})`,
+        query_params: {
+          ids: messages.map((m) => m.id)
+        },
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        },
+        format: "JSONEachRow"
+      });
+      const existingRows = await existingResult.json();
+      const existingSet = new Set(existingRows.map((row) => `${row.id}::${row.thread_id}`));
+      const toInsert = messages.filter((m) => !existingSet.has(`${m.id}::${m.threadId}`));
+      const toUpdate = messages.filter((m) => existingSet.has(`${m.id}::${m.threadId}`));
+      const toMove = messages.filter((m) => {
+        const existingRow = existingRows.find((row) => row.id === m.id);
+        return existingRow && existingRow.thread_id !== m.threadId;
+      });
+      const deletePromises = toMove.map((message) => {
+        const existingRow = existingRows.find((row) => row.id === message.id);
+        if (!existingRow) return Promise.resolve();
+        return this.client.command({
+          query: `DELETE FROM ${TABLE_MESSAGES} WHERE id = {var_id:String} AND thread_id = {var_old_thread_id:String}`,
+          query_params: {
+            var_id: message.id,
+            var_old_thread_id: existingRow.thread_id
+          },
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        });
+      });
+      const updatePromises = toUpdate.map(
+        (message) => this.client.command({
+          query: `
+      ALTER TABLE ${TABLE_MESSAGES}
+      UPDATE content = {var_content:String}, role = {var_role:String}, type = {var_type:String}, resourceId = {var_resourceId:String}
+      WHERE id = {var_id:String} AND thread_id = {var_thread_id:String}
+    `,
+          query_params: {
+            var_content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            var_role: message.role,
+            var_type: message.type || "v2",
+            var_resourceId: message.resourceId,
+            var_id: message.id,
+            var_thread_id: message.threadId
+          },
+          clickhouse_settings: {
+            // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        })
+      );
+      await Promise.all([
+        // Insert new messages (including moved messages)
+        this.client.insert({
+          table: TABLE_MESSAGES,
+          format: "JSONEachRow",
+          values: toInsert.map((message) => ({
+            id: message.id,
+            thread_id: message.threadId,
+            resourceId: message.resourceId,
+            content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            createdAt: message.createdAt.toISOString(),
+            role: message.role,
+            type: message.type || "v2"
+          })),
+          clickhouse_settings: {
+            // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        }),
+        ...updatePromises,
+        ...deletePromises,
+        // Update thread's updatedAt timestamp
+        this.client.insert({
+          table: TABLE_THREADS,
+          format: "JSONEachRow",
+          values: Array.from(threadIdSet.values()).map((thread) => ({
+            id: thread.id,
+            resourceId: thread.resourceId,
+            title: thread.title,
+            metadata: thread.metadata,
+            createdAt: thread.createdAt,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          })),
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        })
+      ]);
+      const list = new MessageList().add(messages, "memory");
+      return { messages: list.get.all.db() };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async getThreadById({ threadId }) {
+    try {
+      const result = await this.client.query({
+        query: `SELECT 
+          id,
+          "resourceId",
+          title,
+          metadata,
+          toDateTime64(createdAt, 3) as createdAt,
+          toDateTime64(updatedAt, 3) as updatedAt
+        FROM "${TABLE_THREADS}"
+        FINAL
+        WHERE id = {var_id:String}`,
+        query_params: { var_id: threadId },
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await result.json();
+      const thread = transformRow(rows.data[0]);
+      if (!thread) {
+        return null;
+      }
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREAD_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.client.insert({
+        table: TABLE_THREADS,
+        values: [
+          {
+            ...thread,
+            createdAt: thread.createdAt.toISOString(),
+            updatedAt: thread.updatedAt.toISOString()
+          }
+        ],
+        format: "JSONEachRow",
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      return thread;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error
+      );
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    try {
+      const existingThread = await this.getThreadById({ threadId: id });
+      if (!existingThread) {
+        throw new Error(`Thread ${id} not found`);
+      }
+      const mergedMetadata = {
+        ...existingThread.metadata,
+        ...metadata
+      };
+      const updatedThread = {
+        ...existingThread,
+        title,
+        metadata: mergedMetadata,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.client.insert({
+        table: TABLE_THREADS,
+        format: "JSONEachRow",
+        values: [
+          {
+            id: updatedThread.id,
+            resourceId: updatedThread.resourceId,
+            title: updatedThread.title,
+            metadata: updatedThread.metadata,
+            createdAt: updatedThread.createdAt,
+            updatedAt: updatedThread.updatedAt.toISOString()
+          }
+        ],
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      return updatedThread;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: id, title }
+        },
+        error
+      );
+    }
+  }
+  async deleteThread({ threadId }) {
+    try {
+      await this.client.command({
+        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
+        query_params: { var_thread_id: threadId },
+        clickhouse_settings: {
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      await this.client.command({
+        query: `DELETE FROM "${TABLE_THREADS}" WHERE id = {var_id:String};`,
+        query_params: { var_id: threadId },
+        clickhouse_settings: {
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
+    }
+  }
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: "STORAGE_CLICKHOUSE_LIST_THREADS_BY_RESOURCE_ID_INVALID_PAGE",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    try {
+      const countResult = await this.client.query({
+        query: `SELECT count() as total FROM ${TABLE_THREADS} WHERE resourceId = {resourceId:String}`,
+        query_params: { resourceId },
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const countData = await countResult.json();
+      const total = countData.data[0].total;
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.query({
+        query: `
+              SELECT
+                id,
+                resourceId,
+                title,
+                metadata,
+                toDateTime64(createdAt, 3) as createdAt,
+                toDateTime64(updatedAt, 3) as updatedAt
+              FROM ${TABLE_THREADS}
+              WHERE resourceId = {resourceId:String}
+              ORDER BY "${field}" ${direction === "DESC" ? "DESC" : "ASC"}
+              LIMIT {perPage:Int64} OFFSET {offset:Int64}
+            `,
+        query_params: {
+          resourceId,
+          perPage,
+          offset
+        },
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await dataResult.json();
+      const threads = transformRows(rows.data);
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: offset + perPage < total
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId, page }
+        },
+        error
+      );
     }
-    return {
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      agentName: row.agent_name,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
-    };
   }
-  async getEvalsByAgentName(agentName, type) {
+  async updateMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) {
+      return [];
+    }
     try {
-      const baseQuery = `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_EVALS} WHERE agent_name = {var_agent_name:String}`;
-      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND JSONExtractString(test_info, 'testPath') IS NOT NULL" : type === "live" ? " AND (test_info IS NULL OR JSONExtractString(test_info, 'testPath') IS NULL)" : "";
-      const result = await this.db.query({
-        query: `${baseQuery}${typeCondition} ORDER BY createdAt DESC`,
-        query_params: { var_agent_name: agentName },
+      const messageIds = messages.map((m) => m.id);
+      const existingResult = await this.client.query({
+        query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${TABLE_MESSAGES} WHERE id IN (${messageIds.map((_, i) => `{id_${i}:String}`).join(",")})`,
+        query_params: messageIds.reduce((acc, m, i) => ({ ...acc, [`id_${i}`]: m }), {}),
         clickhouse_settings: {
           date_time_input_format: "best_effort",
           date_time_output_format: "iso",
@@ -92,131 +860,437 @@ var ClickhouseStore = class extends MastraStorage {
           output_format_json_quote_64bit_integers: 0
         }
       });
-      if (!result) {
+      const existingRows = await existingResult.json();
+      const existingMessages = transformRows(existingRows.data);
+      if (existingMessages.length === 0) {
         return [];
       }
-      const rows = await result.json();
-      return rows.data.map((row) => this.transformEvalRow(row));
+      const parsedExistingMessages = existingMessages.map((msg) => {
+        if (typeof msg.content === "string") {
+          try {
+            msg.content = JSON.parse(msg.content);
+          } catch {
+          }
+        }
+        return msg;
+      });
+      const threadIdsToUpdate = /* @__PURE__ */ new Set();
+      const updatePromises = [];
+      for (const existingMessage of parsedExistingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const values = {};
+        let paramIdx = 1;
+        let newContent = null;
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const existingContent = existingMessage.content || {};
+          const existingMetadata = existingContent.metadata || {};
+          const updateMetadata = updatableFields.content.metadata || {};
+          newContent = {
+            ...existingContent,
+            ...updatableFields.content,
+            // Deep merge metadata
+            metadata: {
+              ...existingMetadata,
+              ...updateMetadata
+            }
+          };
+          setClauses.push(`content = {var_content_${paramIdx}:String}`);
+          values[`var_content_${paramIdx}`] = JSON.stringify(newContent);
+          paramIdx++;
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = key === "threadId" ? "thread_id" : key;
+            setClauses.push(`"${dbColumn}" = {var_${key}_${paramIdx}:String}`);
+            values[`var_${key}_${paramIdx}`] = updatableFields[key];
+            paramIdx++;
+          }
+        }
+        if (setClauses.length > 0) {
+          values[`var_id_${paramIdx}`] = id;
+          const updateQuery = `
+                ALTER TABLE ${TABLE_MESSAGES}
+                UPDATE ${setClauses.join(", ")}
+                WHERE id = {var_id_${paramIdx}:String}
+              `;
+          console.info("Updating message:", id, "with query:", updateQuery, "values:", values);
+          updatePromises.push(
+            this.client.command({
+              query: updateQuery,
+              query_params: values,
+              clickhouse_settings: {
+                date_time_input_format: "best_effort",
+                use_client_time_zone: 1,
+                output_format_json_quote_64bit_integers: 0
+              }
+            })
+          );
+        }
+      }
+      if (updatePromises.length > 0) {
+        await Promise.all(updatePromises);
+      }
+      await this.client.command({
+        query: `OPTIMIZE TABLE ${TABLE_MESSAGES} FINAL`,
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      for (const existingMessage of parsedExistingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        const verifyResult = await this.client.query({
+          query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${TABLE_MESSAGES} WHERE id = {messageId:String}`,
+          query_params: { messageId: id },
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            date_time_output_format: "iso",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        });
+        const verifyRows = await verifyResult.json();
+        if (verifyRows.data.length > 0) {
+          const updatedMessage = transformRows(verifyRows.data)[0];
+          if (updatedMessage) {
+            let needsRetry = false;
+            for (const [key, value] of Object.entries(fieldsToUpdate)) {
+              if (key === "content") {
+                const expectedContent = typeof value === "string" ? value : JSON.stringify(value);
+                const actualContent = typeof updatedMessage.content === "string" ? updatedMessage.content : JSON.stringify(updatedMessage.content);
+                if (actualContent !== expectedContent) {
+                  needsRetry = true;
+                  break;
+                }
+              } else if (updatedMessage[key] !== value) {
+                needsRetry = true;
+                break;
+              }
+            }
+            if (needsRetry) {
+              console.info("Update not applied correctly, retrying with DELETE + INSERT for message:", id);
+              await this.client.command({
+                query: `DELETE FROM ${TABLE_MESSAGES} WHERE id = {messageId:String}`,
+                query_params: { messageId: id },
+                clickhouse_settings: {
+                  date_time_input_format: "best_effort",
+                  use_client_time_zone: 1,
+                  output_format_json_quote_64bit_integers: 0
+                }
+              });
+              let updatedContent = existingMessage.content || {};
+              if (fieldsToUpdate.content) {
+                const existingContent = existingMessage.content || {};
+                const existingMetadata = existingContent.metadata || {};
+                const updateMetadata = fieldsToUpdate.content.metadata || {};
+                updatedContent = {
+                  ...existingContent,
+                  ...fieldsToUpdate.content,
+                  metadata: {
+                    ...existingMetadata,
+                    ...updateMetadata
+                  }
+                };
+              }
+              const updatedMessageData = {
+                ...existingMessage,
+                ...fieldsToUpdate,
+                content: updatedContent
+              };
+              await this.client.insert({
+                table: TABLE_MESSAGES,
+                format: "JSONEachRow",
+                values: [
+                  {
+                    id: updatedMessageData.id,
+                    thread_id: updatedMessageData.threadId,
+                    resourceId: updatedMessageData.resourceId,
+                    content: typeof updatedMessageData.content === "string" ? updatedMessageData.content : JSON.stringify(updatedMessageData.content),
+                    createdAt: updatedMessageData.createdAt.toISOString(),
+                    role: updatedMessageData.role,
+                    type: updatedMessageData.type || "v2"
+                  }
+                ],
+                clickhouse_settings: {
+                  date_time_input_format: "best_effort",
+                  use_client_time_zone: 1,
+                  output_format_json_quote_64bit_integers: 0
+                }
+              });
+            }
+          }
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const now = (/* @__PURE__ */ new Date()).toISOString().replace("Z", "");
+        const threadUpdatePromises = Array.from(threadIdsToUpdate).map(async (threadId) => {
+          const threadResult = await this.client.query({
+            query: `SELECT id, resourceId, title, metadata, createdAt FROM ${TABLE_THREADS} WHERE id = {threadId:String}`,
+            query_params: { threadId },
+            clickhouse_settings: {
+              date_time_input_format: "best_effort",
+              date_time_output_format: "iso",
+              use_client_time_zone: 1,
+              output_format_json_quote_64bit_integers: 0
+            }
+          });
+          const threadRows = await threadResult.json();
+          if (threadRows.data.length > 0) {
+            const existingThread = threadRows.data[0];
+            await this.client.command({
+              query: `DELETE FROM ${TABLE_THREADS} WHERE id = {threadId:String}`,
+              query_params: { threadId },
+              clickhouse_settings: {
+                date_time_input_format: "best_effort",
+                use_client_time_zone: 1,
+                output_format_json_quote_64bit_integers: 0
+              }
+            });
+            await this.client.insert({
+              table: TABLE_THREADS,
+              format: "JSONEachRow",
+              values: [
+                {
+                  id: existingThread.id,
+                  resourceId: existingThread.resourceId,
+                  title: existingThread.title,
+                  metadata: existingThread.metadata,
+                  createdAt: existingThread.createdAt,
+                  updatedAt: now
+                }
+              ],
+              clickhouse_settings: {
+                date_time_input_format: "best_effort",
+                use_client_time_zone: 1,
+                output_format_json_quote_64bit_integers: 0
+              }
+            });
+          }
+        });
+        await Promise.all(threadUpdatePromises);
+      }
+      const updatedMessages = [];
+      for (const messageId of messageIds) {
+        const updatedResult = await this.client.query({
+          query: `SELECT id, content, role, type, "createdAt", thread_id AS "threadId", "resourceId" FROM ${TABLE_MESSAGES} WHERE id = {messageId:String}`,
+          query_params: { messageId },
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            date_time_output_format: "iso",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        });
+        const updatedRows = await updatedResult.json();
+        if (updatedRows.data.length > 0) {
+          const message = transformRows(updatedRows.data)[0];
+          if (message) {
+            updatedMessages.push(message);
+          }
+        }
+      }
+      return updatedMessages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            message.content = JSON.parse(message.content);
+          } catch {
+          }
+        }
+        return message;
+      });
     } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
-        return [];
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messages.map((m) => m.id).join(",") }
+        },
+        error
+      );
+    }
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const result = await this.client.query({
+        query: `SELECT id, workingMemory, metadata, createdAt, updatedAt FROM ${TABLE_RESOURCES} WHERE id = {resourceId:String}`,
+        query_params: { resourceId },
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const rows = await result.json();
+      if (rows.data.length === 0) {
+        return null;
       }
-      this.logger.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
+      const resource = rows.data[0];
+      return {
+        id: resource.id,
+        workingMemory: resource.workingMemory && typeof resource.workingMemory === "object" ? JSON.stringify(resource.workingMemory) : resource.workingMemory,
+        metadata: resource.metadata && typeof resource.metadata === "string" ? JSON.parse(resource.metadata) : resource.metadata,
+        createdAt: new Date(resource.createdAt),
+        updatedAt: new Date(resource.updatedAt)
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_RESOURCE_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
     }
   }
-  async batchInsert({ tableName, records }) {
+  async saveResource({ resource }) {
     try {
-      await this.db.insert({
-        table: tableName,
-        values: records.map((record) => ({
-          ...Object.fromEntries(
-            Object.entries(record).map(([key, value]) => [
-              key,
-              TABLE_SCHEMAS[tableName]?.[key]?.type === "timestamp" ? new Date(value).toISOString() : value
-            ])
-          )
-        })),
+      await this.client.insert({
+        table: TABLE_RESOURCES,
         format: "JSONEachRow",
+        values: [
+          {
+            id: resource.id,
+            workingMemory: resource.workingMemory,
+            metadata: JSON.stringify(resource.metadata),
+            createdAt: resource.createdAt.toISOString(),
+            updatedAt: resource.updatedAt.toISOString()
+          }
+        ],
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
         }
       });
+      return resource;
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_RESOURCE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId: resource.id }
+        },
+        error
+      );
     }
   }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters,
-    fromDate,
-    toDate
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
   }) {
-    const limit = perPage;
-    const offset = page * perPage;
-    const args = {};
-    const conditions = [];
-    if (name) {
-      conditions.push(`name LIKE CONCAT({var_name:String}, '%')`);
-      args.var_name = name;
-    }
-    if (scope) {
-      conditions.push(`scope = {var_scope:String}`);
-      args.var_scope = scope;
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        conditions.push(`JSONExtractString(attributes, '${key}') = {var_attr_${key}:String}`);
-        args[`var_attr_${key}`] = value;
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        conditions.push(
-          `${key} = {var_col_${key}:${COLUMN_TYPES[TABLE_SCHEMAS.mastra_traces?.[key]?.type ?? "text"]}}`
-        );
-        args[`var_col_${key}`] = value;
-      });
-    }
-    if (fromDate) {
-      conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
-      args.var_from_date = fromDate.getTime() / 1e3;
-    }
-    if (toDate) {
-      conditions.push(`createdAt <= {var_to_date:DateTime64(3)}`);
-      args.var_to_date = toDate.getTime() / 1e3;
-    }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const result = await this.db.query({
-      query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      query_params: args,
-      clickhouse_settings: {
-        // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-        date_time_input_format: "best_effort",
-        date_time_output_format: "iso",
-        use_client_time_zone: 1,
-        output_format_json_quote_64bit_integers: 0
+    try {
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
       }
-    });
-    if (!result) {
-      return [];
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const updateQuery = `
+            ALTER TABLE ${TABLE_RESOURCES}
+            UPDATE workingMemory = {workingMemory:String}, metadata = {metadata:String}, updatedAt = {updatedAt:String}
+            WHERE id = {resourceId:String}
+          `;
+      await this.client.command({
+        query: updateQuery,
+        query_params: {
+          workingMemory: updatedResource.workingMemory,
+          metadata: JSON.stringify(updatedResource.metadata),
+          updatedAt: updatedResource.updatedAt.toISOString().replace("Z", ""),
+          resourceId
+        },
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      await this.client.command({
+        query: `OPTIMIZE TABLE ${TABLE_RESOURCES} FINAL`,
+        clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      return updatedResource;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_RESOURCE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
     }
-    const resp = await result.json();
-    const rows = resp.data;
-    return rows.map((row) => ({
-      id: row.id,
-      parentSpanId: row.parentSpanId,
-      traceId: row.traceId,
-      name: row.name,
-      scope: row.scope,
-      kind: row.kind,
-      status: safelyParseJSON(row.status),
-      events: safelyParseJSON(row.events),
-      links: safelyParseJSON(row.links),
-      attributes: safelyParseJSON(row.attributes),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other),
-      createdAt: row.createdAt
-    }));
   }
-  async optimizeTable({ tableName }) {
-    await this.db.command({
-      query: `OPTIMIZE TABLE ${tableName} FINAL`
-    });
+};
+var StoreOperationsClickhouse = class extends StoreOperations {
+  ttl;
+  client;
+  constructor({ client, ttl }) {
+    super();
+    this.ttl = ttl;
+    this.client = client;
   }
-  async materializeTtl({ tableName }) {
-    await this.db.command({
-      query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`
+  async hasColumn(table, column) {
+    const result = await this.client.query({
+      query: `DESCRIBE TABLE ${table}`,
+      format: "JSONEachRow"
     });
+    const columns = await result.json();
+    return columns.some((c) => c.name === column);
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "String";
+      case "timestamp":
+        return "DateTime64(3)";
+      case "integer":
+      case "bigint":
+        return "Int64";
+      case "jsonb":
+        return "String";
+      default:
+        return super.getSqlType(type);
+    }
   }
   async createTable({
     tableName,
@@ -231,27 +1305,25 @@ var ClickhouseStore = class extends MastraStorage {
       }).join(",\n");
       const rowTtl = this.ttl?.[tableName]?.row;
       const sql = tableName === TABLE_WORKFLOW_SNAPSHOT ? `
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          ${["id String"].concat(columns)}
-        )
-        ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
-        PRIMARY KEY (createdAt, run_id, workflow_name)
-        ORDER BY (createdAt, run_id, workflow_name)
-        ${rowTtl ? `TTL toDateTime(${rowTtl.ttlKey ?? "createdAt"}) + INTERVAL ${rowTtl.interval} ${rowTtl.unit}` : ""}
-        SETTINGS index_granularity = 8192
-          ` : `
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          ${columns}
-        )
-        ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
-        PRIMARY KEY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
-        ORDER BY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
-        ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ""}
-        SETTINGS index_granularity = 8192
-      `;
-      await this.db.query({
+            CREATE TABLE IF NOT EXISTS ${tableName} (
+              ${["id String"].concat(columns)}
+            )
+            ENGINE = ${TABLE_ENGINES[tableName] ?? "MergeTree()"}
+            PRIMARY KEY (createdAt, run_id, workflow_name)
+            ORDER BY (createdAt, run_id, workflow_name)
+            ${rowTtl ? `TTL toDateTime(${rowTtl.ttlKey ?? "createdAt"}) + INTERVAL ${rowTtl.interval} ${rowTtl.unit}` : ""}
+            SETTINGS index_granularity = 8192
+              ` : `
+            CREATE TABLE IF NOT EXISTS ${tableName} (
+              ${columns}
+            )
+            ENGINE = ${TABLE_ENGINES[tableName] ?? "MergeTree()"}
+            PRIMARY KEY (createdAt, ${"id"})
+            ORDER BY (createdAt, ${"id"})
+            ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ""}
+            SETTINGS index_granularity = 8192
+          `;
+      await this.client.query({
         query: sql,
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
@@ -262,13 +1334,59 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error creating table ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CREATE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    try {
+      const describeSql = `DESCRIBE TABLE ${tableName}`;
+      const result = await this.client.query({
+        query: describeSql
+      });
+      const rows = await result.json();
+      const existingColumnNames = new Set(rows.data.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          let sqlType = this.getSqlType(columnDef.type);
+          if (columnDef.nullable !== false) {
+            sqlType = `Nullable(${sqlType})`;
+          }
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${tableName} ADD COLUMN IF NOT EXISTS "${columnName}" ${sqlType} ${defaultValue}`.trim();
+          await this.client.query({
+            query: alterSql
+          });
+          this.logger?.debug?.(`Added column ${columnName} to table ${tableName}`);
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_ALTER_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async clearTable({ tableName }) {
     try {
-      await this.db.query({
+      await this.client.query({
         query: `TRUNCATE TABLE ${tableName}`,
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
@@ -279,19 +1397,33 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error clearing table ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CLEAR_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
+  async dropTable({ tableName }) {
+    await this.client.query({
+      query: `DROP TABLE IF EXISTS ${tableName}`
+    });
+  }
   async insert({ tableName, record }) {
+    const createdAt = (record.createdAt || record.created_at || /* @__PURE__ */ new Date()).toISOString();
+    const updatedAt = (record.updatedAt || /* @__PURE__ */ new Date()).toISOString();
     try {
-      await this.db.insert({
+      const result = await this.client.insert({
         table: tableName,
         values: [
           {
             ...record,
-            createdAt: record.createdAt.toISOString(),
-            updatedAt: record.updatedAt.toISOString()
+            createdAt,
+            updatedAt
           }
         ],
         format: "JSONEachRow",
@@ -302,13 +1434,55 @@ var ClickhouseStore = class extends MastraStorage {
           use_client_time_zone: 1
         }
       });
+      console.info("INSERT RESULT", result);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    const recordsToBeInserted = records.map((record) => ({
+      ...Object.fromEntries(
+        Object.entries(record).map(([key, value]) => [
+          key,
+          TABLE_SCHEMAS[tableName]?.[key]?.type === "timestamp" ? new Date(value).toISOString() : value
+        ])
+      )
+    }));
+    try {
+      await this.client.insert({
+        table: tableName,
+        values: recordsToBeInserted,
+        format: "JSONEachRow",
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async load({ tableName, keys }) {
     try {
+      const engine = TABLE_ENGINES[tableName] ?? "MergeTree()";
       const keyEntries = Object.entries(keys);
       const conditions = keyEntries.map(
         ([key]) => `"${key}" = {var_${key}:${COLUMN_TYPES[TABLE_SCHEMAS[tableName]?.[key]?.type ?? "text"]}}`
@@ -316,8 +1490,10 @@ var ClickhouseStore = class extends MastraStorage {
       const values = keyEntries.reduce((acc, [key, value]) => {
         return { ...acc, [`var_${key}`]: value };
       }, {});
-      const result = await this.db.query({
-        query: `SELECT *, toDateTime64(createdAt, 3) as createdAt, toDateTime64(updatedAt, 3) as updatedAt FROM ${tableName} ${TABLE_ENGINES[tableName].startsWith("ReplacingMergeTree") ? "FINAL" : ""} WHERE ${conditions}`,
+      const hasUpdatedAt = TABLE_SCHEMAS[tableName]?.updatedAt;
+      const selectClause = `SELECT *, toDateTime64(createdAt, 3) as createdAt${hasUpdatedAt ? ", toDateTime64(updatedAt, 3) as updatedAt" : ""}`;
+      const result = await this.client.query({
+        query: `${selectClause} FROM ${tableName} ${engine.startsWith("ReplacingMergeTree") ? "FINAL" : ""} WHERE ${conditions} ORDER BY createdAt DESC LIMIT 1`,
         query_params: values,
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
@@ -344,24 +1520,57 @@ var ClickhouseStore = class extends MastraStorage {
       const data = transformRow(rows.data[0]);
       return data;
     } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
-  async getThreadById({ threadId }) {
+};
+var ScoresStorageClickhouse = class extends ScoresStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  transformScoreRow(row) {
+    const scorer = safelyParseJSON(row.scorer);
+    const preprocessStepResult = safelyParseJSON(row.preprocessStepResult);
+    const analyzeStepResult = safelyParseJSON(row.analyzeStepResult);
+    const metadata = safelyParseJSON(row.metadata);
+    const input = safelyParseJSON(row.input);
+    const output = safelyParseJSON(row.output);
+    const additionalContext = safelyParseJSON(row.additionalContext);
+    const requestContext = safelyParseJSON(row.requestContext);
+    const entity = safelyParseJSON(row.entity);
+    return {
+      ...row,
+      scorer,
+      preprocessStepResult,
+      analyzeStepResult,
+      metadata,
+      input,
+      output,
+      additionalContext,
+      requestContext,
+      entity,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt)
+    };
+  }
+  async getScoreById({ id }) {
     try {
-      const result = await this.db.query({
-        query: `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          toDateTime64(createdAt, 3) as createdAt,
-          toDateTime64(updatedAt, 3) as updatedAt
-        FROM "${TABLE_THREADS}"
-        FINAL
-        WHERE id = {var_id:String}`,
-        query_params: { var_id: threadId },
+      const result = await this.client.query({
+        query: `SELECT * FROM ${TABLE_SCORERS} WHERE id = {var_id:String}`,
+        query_params: { var_id: id },
+        format: "JSONEachRow",
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
@@ -370,223 +1579,269 @@ var ClickhouseStore = class extends MastraStorage {
           output_format_json_quote_64bit_integers: 0
         }
       });
-      const rows = await result.json();
-      const thread = transformRow(rows.data[0]);
-      if (!thread) {
+      const resultJson = await result.json();
+      if (!Array.isArray(resultJson) || resultJson.length === 0) {
         return null;
       }
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      };
+      return this.transformScoreRow(resultJson[0]);
     } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORE_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { scoreId: id }
+        },
+        error
+      );
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
+  async saveScore(score) {
+    let parsedScore;
     try {
-      const result = await this.db.query({
-        query: `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          toDateTime64(createdAt, 3) as createdAt,
-          toDateTime64(updatedAt, 3) as updatedAt
-        FROM "${TABLE_THREADS}"
-        WHERE "resourceId" = {var_resourceId:String}`,
-        query_params: { var_resourceId: resourceId },
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: "best_effort",
-          date_time_output_format: "iso",
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0
-        }
-      });
-      const rows = await result.json();
-      const threads = transformRows(rows.data);
-      return threads.map((thread) => ({
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      }));
+      parsedScore = saveScorePayloadSchema.parse(score);
     } catch (error) {
-      console.error(`Error getting threads for resource ${resourceId}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_SCORE_FAILED_INVALID_SCORE_PAYLOAD",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { scoreId: score.id }
+        },
+        error
+      );
     }
-  }
-  async saveThread({ thread }) {
     try {
-      await this.db.insert({
-        table: TABLE_THREADS,
-        values: [
-          {
-            ...thread,
-            createdAt: thread.createdAt.toISOString(),
-            updatedAt: thread.updatedAt.toISOString()
-          }
-        ],
+      const record = {
+        ...parsedScore
+      };
+      await this.client.insert({
+        table: TABLE_SCORERS,
+        values: [record],
         format: "JSONEachRow",
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
         }
       });
-      return thread;
+      return { score };
     } catch (error) {
-      console.error("Error saving thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_SCORE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { scoreId: score.id }
+        },
+        error
+      );
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
+  async listScoresByRunId({
+    runId,
+    pagination
   }) {
     try {
-      const existingThread = await this.getThreadById({ threadId: id });
-      if (!existingThread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-      const mergedMetadata = {
-        ...existingThread.metadata,
-        ...metadata
-      };
-      const updatedThread = {
-        ...existingThread,
-        title,
-        metadata: mergedMetadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      await this.db.insert({
-        table: TABLE_THREADS,
-        values: [
-          {
-            ...updatedThread,
-            updatedAt: updatedThread.updatedAt.toISOString()
-          }
-        ],
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${TABLE_SCORERS} WHERE runId = {var_runId:String}`,
+        query_params: { var_runId: runId },
+        format: "JSONEachRow"
+      });
+      const countRows = await countResult.json();
+      let total = 0;
+      if (Array.isArray(countRows) && countRows.length > 0 && countRows[0]) {
+        const countObj = countRows[0];
+        total = Number(countObj.count);
+      }
+      const { page, perPage: perPageInput } = pagination;
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${TABLE_SCORERS} WHERE runId = {var_runId:String} ORDER BY createdAt DESC LIMIT {var_limit:Int64} OFFSET {var_offset:Int64}`,
+        query_params: {
+          var_runId: runId,
+          var_limit: limitValue,
+          var_offset: start
+        },
         format: "JSONEachRow",
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
         }
       });
-      return updatedThread;
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
     } catch (error) {
-      console.error("Error updating thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_RUN_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId }
+        },
+        error
+      );
     }
   }
-  async deleteThread({ threadId }) {
+  async listScoresByScorerId({
+    scorerId,
+    entityId,
+    entityType,
+    source,
+    pagination
+  }) {
+    let whereClause = `scorerId = {var_scorerId:String}`;
+    if (entityId) {
+      whereClause += ` AND entityId = {var_entityId:String}`;
+    }
+    if (entityType) {
+      whereClause += ` AND entityType = {var_entityType:String}`;
+    }
+    if (source) {
+      whereClause += ` AND source = {var_source:String}`;
+    }
     try {
-      await this.db.command({
-        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = '${threadId}';`,
-        query_params: { var_thread_id: threadId },
-        clickhouse_settings: {
-          output_format_json_quote_64bit_integers: 0
-        }
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${TABLE_SCORERS} WHERE ${whereClause}`,
+        query_params: {
+          var_scorerId: scorerId,
+          var_entityId: entityId,
+          var_entityType: entityType,
+          var_source: source
+        },
+        format: "JSONEachRow"
       });
-      await this.db.command({
-        query: `DELETE FROM "${TABLE_THREADS}" WHERE id = {var_id:String};`,
-        query_params: { var_id: threadId },
+      const countRows = await countResult.json();
+      let total = 0;
+      if (Array.isArray(countRows) && countRows.length > 0 && countRows[0]) {
+        const countObj = countRows[0];
+        total = Number(countObj.count);
+      }
+      const { page, perPage: perPageInput } = pagination;
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${TABLE_SCORERS} WHERE ${whereClause} ORDER BY createdAt DESC LIMIT {var_limit:Int64} OFFSET {var_offset:Int64}`,
+        query_params: {
+          var_scorerId: scorerId,
+          var_limit: limitValue,
+          var_offset: start,
+          var_entityId: entityId,
+          var_entityType: entityType,
+          var_source: source
+        },
+        format: "JSONEachRow",
         clickhouse_settings: {
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
         }
       });
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
     } catch (error) {
-      console.error("Error deleting thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { scorerId }
+        },
+        error
+      );
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
     try {
-      const messages = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-      const include = selectBy?.include || [];
-      if (include.length) {
-        const includeResult = await this.db.query({
-          query: `
-          WITH ordered_messages AS (
-            SELECT 
-              *,
-              toDateTime64(createdAt, 3) as createdAt,
-              toDateTime64(updatedAt, 3) as updatedAt,
-              ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
-            FROM "${TABLE_MESSAGES}"
-            WHERE thread_id = {var_thread_id:String}
-          )
-          SELECT
-            m.id AS id, 
-            m.content as content, 
-            m.role as role, 
-            m.type as type,
-            m.createdAt as createdAt, 
-            m.updatedAt as updatedAt,
-            m.thread_id AS "threadId"
-          FROM ordered_messages m
-          WHERE m.id = ANY({var_include:Array(String)})
-          OR EXISTS (
-            SELECT 1 FROM ordered_messages target
-            WHERE target.id = ANY({var_include:Array(String)})
-            AND (
-              -- Get previous messages based on the max withPreviousMessages
-              (m.row_num <= target.row_num + {var_withPreviousMessages:Int64} AND m.row_num > target.row_num)
-              OR
-              -- Get next messages based on the max withNextMessages
-              (m.row_num >= target.row_num - {var_withNextMessages:Int64} AND m.row_num < target.row_num)
-            )
-          )
-          ORDER BY m."createdAt" DESC
-          `,
-          query_params: {
-            var_thread_id: threadId,
-            var_include: include.map((i) => i.id),
-            var_withPreviousMessages: Math.max(...include.map((i) => i.withPreviousMessages || 0)),
-            var_withNextMessages: Math.max(...include.map((i) => i.withNextMessages || 0))
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${TABLE_SCORERS} WHERE entityId = {var_entityId:String} AND entityType = {var_entityType:String}`,
+        query_params: { var_entityId: entityId, var_entityType: entityType },
+        format: "JSONEachRow"
+      });
+      const countRows = await countResult.json();
+      let total = 0;
+      if (Array.isArray(countRows) && countRows.length > 0 && countRows[0]) {
+        const countObj = countRows[0];
+        total = Number(countObj.count);
+      }
+      const { page, perPage: perPageInput } = pagination;
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
           },
-          clickhouse_settings: {
-            // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-            date_time_input_format: "best_effort",
-            date_time_output_format: "iso",
-            use_client_time_zone: 1,
-            output_format_json_quote_64bit_integers: 0
-          }
-        });
-        const rows2 = await includeResult.json();
-        messages.push(...transformRows(rows2.data));
+          scores: []
+        };
       }
-      const result = await this.db.query({
-        query: `
-        SELECT 
-            id, 
-            content, 
-            role, 
-            type,
-            toDateTime64(createdAt, 3) as createdAt,
-            thread_id AS "threadId"
-        FROM "${TABLE_MESSAGES}"
-        WHERE thread_id = {threadId:String}
-        AND id NOT IN ({exclude:Array(String)})
-        ORDER BY "createdAt" DESC
-        LIMIT {limit:Int64}
-        `,
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${TABLE_SCORERS} WHERE entityId = {var_entityId:String} AND entityType = {var_entityType:String} ORDER BY createdAt DESC LIMIT {var_limit:Int64} OFFSET {var_offset:Int64}`,
         query_params: {
-          threadId,
-          exclude: messages.map((m) => m.id),
-          limit
+          var_entityId: entityId,
+          var_entityType: entityType,
+          var_limit: limitValue,
+          var_offset: start
         },
+        format: "JSONEachRow",
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
           date_time_output_format: "iso",
           use_client_time_zone: 1,
@@ -594,80 +1849,154 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
       const rows = await result.json();
-      messages.push(...transformRows(rows.data));
-      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-      messages.forEach((message) => {
-        if (typeof message.content === "string") {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-          }
-        }
-      });
-      return messages;
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
     } catch (error) {
-      console.error("Error getting messages:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { entityId, entityType }
+        },
+        error
+      );
     }
   }
-  async saveMessages({ messages }) {
-    if (messages.length === 0) return messages;
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
     try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${TABLE_SCORERS} WHERE traceId = {var_traceId:String} AND spanId = {var_spanId:String}`,
+        query_params: {
+          var_traceId: traceId,
+          var_spanId: spanId
+        },
+        format: "JSONEachRow"
+      });
+      const countRows = await countResult.json();
+      let total = 0;
+      if (Array.isArray(countRows) && countRows.length > 0 && countRows[0]) {
+        const countObj = countRows[0];
+        total = Number(countObj.count);
       }
-      const thread = await this.getThreadById({ threadId });
-      if (!thread) {
-        throw new Error(`Thread ${threadId} not found`);
+      const { page, perPage: perPageInput } = pagination;
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage: perPageInput,
+            hasMore: false
+          },
+          scores: []
+        };
       }
-      await this.db.insert({
-        table: TABLE_MESSAGES,
+      const perPage = normalizePerPage(perPageInput, 100);
+      const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+      const limitValue = perPageInput === false ? total : perPage;
+      const end = perPageInput === false ? total : start + perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${TABLE_SCORERS} WHERE traceId = {var_traceId:String} AND spanId = {var_spanId:String} ORDER BY createdAt DESC LIMIT {var_limit:Int64} OFFSET {var_offset:Int64}`,
+        query_params: {
+          var_traceId: traceId,
+          var_spanId: spanId,
+          var_limit: limitValue,
+          var_offset: start
+        },
         format: "JSONEachRow",
-        values: messages.map((message) => ({
-          id: message.id,
-          thread_id: threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          createdAt: message.createdAt.toISOString(),
-          role: message.role,
-          type: message.type
-        })),
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
         }
       });
-      return messages;
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page,
+          perPage: perPageForResponse,
+          hasMore: end < total
+        },
+        scores
+      };
     } catch (error) {
-      console.error("Error saving messages:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_SPAN_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { traceId, spanId }
+        },
+        error
+      );
     }
   }
+};
+var WorkflowsStorageClickhouse = class extends WorkflowsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // requestContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
+    resourceId,
     snapshot
   }) {
     try {
-      const currentSnapshot = await this.load({
+      const currentSnapshot = await this.operations.load({
         tableName: TABLE_WORKFLOW_SNAPSHOT,
         keys: { workflow_name: workflowName, run_id: runId }
       });
       const now = /* @__PURE__ */ new Date();
       const persisting = currentSnapshot ? {
         ...currentSnapshot,
+        resourceId,
         snapshot: JSON.stringify(snapshot),
         updatedAt: now.toISOString()
       } : {
         workflow_name: workflowName,
         run_id: runId,
+        resourceId,
         snapshot: JSON.stringify(snapshot),
         createdAt: now.toISOString(),
         updatedAt: now.toISOString()
       };
-      await this.db.insert({
+      await this.client.insert({
         table: TABLE_WORKFLOW_SNAPSHOT,
         format: "JSONEachRow",
         values: [persisting],
@@ -679,8 +2008,15 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error("Error persisting workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -688,7 +2024,7 @@ var ClickhouseStore = class extends MastraStorage {
     runId
   }) {
     try {
-      const result = await this.load({
+      const result = await this.operations.load({
         tableName: TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -700,8 +2036,15 @@ var ClickhouseStore = class extends MastraStorage {
       }
       return result.snapshot;
     } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   parseWorkflowRun(row) {
@@ -722,12 +2065,12 @@ var ClickhouseStore = class extends MastraStorage {
       resourceId: row.resourceId
     };
   }
-  async getWorkflowRuns({
+  async listWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
-    limit,
-    offset,
+    page,
+    perPage,
     resourceId
   } = {}) {
     try {
@@ -738,7 +2081,7 @@ var ClickhouseStore = class extends MastraStorage {
         values.var_workflow_name = workflowName;
       }
       if (resourceId) {
-        const hasResourceId = await this.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.operations.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push(`resourceId = {var_resourceId:String}`);
           values.var_resourceId = resourceId;
@@ -755,11 +2098,14 @@ var ClickhouseStore = class extends MastraStorage {
         values.var_to_date = toDate.getTime() / 1e3;
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const limitClause = limit !== void 0 ? `LIMIT ${limit}` : "";
-      const offsetClause = offset !== void 0 ? `OFFSET ${offset}` : "";
+      const usePagination = perPage !== void 0 && page !== void 0;
+      const normalizedPerPage = usePagination ? normalizePerPage(perPage, Number.MAX_SAFE_INTEGER) : 0;
+      const offset = usePagination ? page * normalizedPerPage : 0;
+      const limitClause = usePagination ? `LIMIT ${normalizedPerPage}` : "";
+      const offsetClause = usePagination ? `OFFSET ${offset}` : "";
       let total = 0;
-      if (limit !== void 0 && offset !== void 0) {
-        const countResult = await this.db.query({
+      if (usePagination) {
+        const countResult = await this.client.query({
           query: `SELECT COUNT(*) as count FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""} ${whereClause}`,
           query_params: values,
           format: "JSONEachRow"
@@ -767,21 +2113,21 @@ var ClickhouseStore = class extends MastraStorage {
         const countRows = await countResult.json();
         total = Number(countRows[0]?.count ?? 0);
       }
-      const result = await this.db.query({
+      const result = await this.client.query({
         query: `
-          SELECT 
-            workflow_name,
-            run_id,
-            snapshot,
-            toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt,
-            resourceId
-          FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
-          ${whereClause}
-          ORDER BY createdAt DESC
-          ${limitClause}
-          ${offsetClause}
-        `,
+              SELECT 
+                workflow_name,
+                run_id,
+                snapshot,
+                toDateTime64(createdAt, 3) as createdAt,
+                toDateTime64(updatedAt, 3) as updatedAt,
+                resourceId
+              FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
+              ${whereClause}
+              ORDER BY createdAt DESC
+              ${limitClause}
+              ${offsetClause}
+            `,
         query_params: values,
         format: "JSONEachRow"
       });
@@ -792,8 +2138,15 @@ var ClickhouseStore = class extends MastraStorage {
       });
       return { runs, total: total || runs.length };
     } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LIST_WORKFLOW_RUNS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName: workflowName ?? "", resourceId: resourceId ?? "" }
+        },
+        error
+      );
     }
   }
   async getWorkflowRunById({
@@ -812,18 +2165,19 @@ var ClickhouseStore = class extends MastraStorage {
         values.var_workflow_name = workflowName;
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const result = await this.db.query({
+      const result = await this.client.query({
         query: `
-          SELECT 
-            workflow_name,
-            run_id,
-            snapshot,
-            toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt,
-            resourceId
-          FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
-          ${whereClause}
-        `,
+              SELECT 
+                workflow_name,
+                run_id,
+                snapshot,
+                toDateTime64(createdAt, 3) as createdAt,
+                toDateTime64(updatedAt, 3) as updatedAt,
+                resourceId
+              FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
+              ${whereClause}
+              ORDER BY createdAt DESC LIMIT 1
+            `,
         query_params: values,
         format: "JSONEachRow"
       });
@@ -833,17 +2187,244 @@ var ClickhouseStore = class extends MastraStorage {
       }
       return this.parseWorkflowRun(resultJson[0]);
     } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId: runId ?? "", workflowName: workflowName ?? "" }
+        },
+        error
+      );
     }
   }
-  async hasColumn(table, column) {
-    const result = await this.db.query({
-      query: `DESCRIBE TABLE ${table}`,
-      format: "JSONEachRow"
+};
+
+// src/storage/index.ts
+var ClickhouseStore = class extends MastraStorage {
+  db;
+  ttl = {};
+  stores;
+  constructor(config) {
+    super({ name: "ClickhouseStore" });
+    this.db = createClient({
+      url: config.url,
+      username: config.username,
+      password: config.password,
+      clickhouse_settings: {
+        date_time_input_format: "best_effort",
+        date_time_output_format: "iso",
+        // This is crucial
+        use_client_time_zone: 1,
+        output_format_json_quote_64bit_integers: 0
+      }
     });
-    const columns = await result.json();
-    return columns.some((c) => c.name === column);
+    this.ttl = config.ttl;
+    const operations = new StoreOperationsClickhouse({ client: this.db, ttl: this.ttl });
+    const workflows = new WorkflowsStorageClickhouse({ client: this.db, operations });
+    const scores = new ScoresStorageClickhouse({ client: this.db, operations });
+    const memory = new MemoryStorageClickhouse({ client: this.db, operations });
+    this.stores = {
+      operations,
+      workflows,
+      scores,
+      memory
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: false,
+      listScoresBySpan: true
+    };
+  }
+  async batchInsert({ tableName, records }) {
+    await this.stores.operations.batchInsert({ tableName, records });
+  }
+  async optimizeTable({ tableName }) {
+    try {
+      await this.db.command({
+        query: `OPTIMIZE TABLE ${tableName} FINAL`
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_OPTIMIZE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async materializeTtl({ tableName }) {
+    try {
+      await this.db.command({
+        query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_MATERIALIZE_TTL_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    return this.stores.operations.createTable({ tableName, schema });
+  }
+  async dropTable({ tableName }) {
+    return this.stores.operations.dropTable({ tableName });
+  }
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
+  }
+  async clearTable({ tableName }) {
+    return this.stores.operations.clearTable({ tableName });
+  }
+  async insert({ tableName, record }) {
+    return this.stores.operations.insert({ tableName, record });
+  }
+  async load({ tableName, keys }) {
+    return this.stores.operations.load({ tableName, keys });
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    requestContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async listWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    perPage,
+    page,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.listWorkflowRuns({ workflowName, fromDate, toDate, perPage, page, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy
+  }) {
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages(args) {
+    return this.stores.memory.updateMessages(args);
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
+  async saveResource({ resource }) {
+    return this.stores.memory.saveResource({ resource });
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+  async getScoreById({ id }) {
+    return this.stores.scores.getScoreById({ id });
+  }
+  async saveScore(_score) {
+    return this.stores.scores.saveScore(_score);
+  }
+  async listScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.listScoresByRunId({ runId, pagination });
+  }
+  async listScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
+  }
+  async listScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source
+  }) {
+    return this.stores.scores.listScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
+  }
+  async listScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
   }
   async close() {
     await this.db.close();
@@ -851,3 +2432,5 @@ var ClickhouseStore = class extends MastraStorage {
 };
 
 export { COLUMN_TYPES, ClickhouseStore, TABLE_ENGINES };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map