@mastra/clickhouse 0.0.0-taofeeqInngest-20250603090617 → 0.0.0-transpile-packages-20250724123433

package/dist/index.cjs

@@ -1,23 +1,19 @@
 'use strict';
 
 var client = require('@clickhouse/client');
-var agent = require('@mastra/core/agent');
+var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
+var agent = require('@mastra/core/agent');
 
 // src/storage/index.ts
-function safelyParseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
 var TABLE_ENGINES = {
   [storage.TABLE_MESSAGES]: `MergeTree()`,
   [storage.TABLE_WORKFLOW_SNAPSHOT]: `ReplacingMergeTree()`,
   [storage.TABLE_TRACES]: `MergeTree()`,
   [storage.TABLE_THREADS]: `ReplacingMergeTree()`,
-  [storage.TABLE_EVALS]: `MergeTree()`
+  [storage.TABLE_EVALS]: `MergeTree()`,
+  [storage.TABLE_SCORERS]: `MergeTree()`,
+  [storage.TABLE_RESOURCES]: `ReplacingMergeTree()`
 };
 var COLUMN_TYPES = {
   text: "String",
@@ -25,11 +21,9 @@ var COLUMN_TYPES = {
   uuid: "String",
   jsonb: "String",
   integer: "Int64",
+  float: "Float64",
   bigint: "Int64"
 };
-function transformRows(rows) {
-  return rows.map((row) => transformRow(row));
-}
 function transformRow(row) {
   if (!row) {
     return row;
@@ -40,33 +34,63 @@ function transformRow(row) {
   if (row.updatedAt) {
     row.updatedAt = new Date(row.updatedAt);
   }
+  if (row.content && typeof row.content === "string") {
+    row.content = storage.safelyParseJSON(row.content);
+  }
   return row;
 }
-var ClickhouseStore = class extends storage.MastraStorage {
-  db;
-  ttl = {};
-  constructor(config) {
-    super({ name: "ClickhouseStore" });
-    this.db = client.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
-      }
-    });
-    this.ttl = config.ttl;
+function transformRows(rows) {
+  return rows.map((row) => transformRow(row));
+}
+
+// src/storage/domains/legacy-evals/index.ts
+var LegacyEvalsStorageClickhouse = class extends storage.LegacyEvalsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
   }
   transformEvalRow(row) {
     row = transformRow(row);
-    const resultValue = JSON.parse(row.result);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
+    let resultValue;
+    try {
+      if (row.result && typeof row.result === "string" && row.result.trim() !== "") {
+        resultValue = JSON.parse(row.result);
+      } else if (typeof row.result === "object" && row.result !== null) {
+        resultValue = row.result;
+      } else if (row.result === null || row.result === void 0 || row.result === "") {
+        resultValue = { score: 0 };
+      } else {
+        throw new Error(`Invalid or empty result field: ${JSON.stringify(row.result)}`);
+      }
+    } catch (error$1) {
+      console.error("Error parsing result field:", row.result, error$1);
+      throw new error.MastraError({
+        id: "CLICKHOUSE_STORAGE_INVALID_RESULT_FORMAT",
+        text: `Invalid result format: ${JSON.stringify(row.result)}`,
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER
+      });
+    }
+    let testInfoValue;
+    try {
+      if (row.test_info && typeof row.test_info === "string" && row.test_info.trim() !== "" && row.test_info !== "null") {
+        testInfoValue = JSON.parse(row.test_info);
+      } else if (typeof row.test_info === "object" && row.test_info !== null) {
+        testInfoValue = row.test_info;
+      }
+    } catch {
+      testInfoValue = void 0;
+    }
     if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
+      throw new error.MastraError({
+        id: "CLICKHOUSE_STORAGE_INVALID_METRIC_FORMAT",
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER
+      });
     }
     return {
       input: row.input,
@@ -83,9 +107,9 @@ var ClickhouseStore = class extends storage.MastraStorage {
   }
   async getEvalsByAgentName(agentName, type) {
     try {
-      const baseQuery = `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${storage.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({
+      const baseQuery = `SELECT *, toDateTime64(created_at, 3) as createdAt FROM ${storage.TABLE_EVALS} WHERE agent_name = {var_agent_name:String}`;
+      const typeCondition = type === "test" ? " AND test_info IS NOT NULL AND test_info != 'null' AND JSONExtractString(test_info, 'testPath') IS NOT NULL AND JSONExtractString(test_info, 'testPath') != ''" : type === "live" ? " AND (test_info IS NULL OR test_info = 'null' OR JSONExtractString(test_info, 'testPath') IS NULL OR JSONExtractString(test_info, 'testPath') = '')" : "";
+      const result = await this.client.query({
         query: `${baseQuery}${typeCondition} ORDER BY createdAt DESC`,
         query_params: { var_agent_name: agentName },
         clickhouse_settings: {
@@ -100,126 +124,1293 @@ var ClickhouseStore = class extends storage.MastraStorage {
       }
       const rows = await result.json();
       return rows.data.map((row) => this.transformEvalRow(row));
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("no such table")) {
+    } catch (error$1) {
+      if (error$1?.message?.includes("no such table") || error$1?.message?.includes("does not exist")) {
         return [];
       }
-      this.logger.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_EVALS_BY_AGENT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName, type: type ?? null }
+        },
+        error$1
+      );
     }
   }
-  async batchInsert({ tableName, records }) {
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const conditions = [];
+    if (agentName) {
+      conditions.push(`agent_name = {var_agent_name:String}`);
+    }
+    if (type === "test") {
+      conditions.push(
+        `(test_info IS NOT NULL AND test_info != 'null' AND JSONExtractString(test_info, 'testPath') IS NOT NULL AND JSONExtractString(test_info, 'testPath') != '')`
+      );
+    } else if (type === "live") {
+      conditions.push(
+        `(test_info IS NULL OR test_info = 'null' OR JSONExtractString(test_info, 'testPath') IS NULL OR JSONExtractString(test_info, 'testPath') = '')`
+      );
+    }
+    if (fromDate) {
+      conditions.push(`created_at >= parseDateTime64BestEffort({var_from_date:String})`);
+      fromDate.toISOString();
+    }
+    if (toDate) {
+      conditions.push(`created_at <= parseDateTime64BestEffort({var_to_date:String})`);
+      toDate.toISOString();
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     try {
-      await this.db.insert({
-        table: tableName,
-        values: records.map((record) => ({
-          ...Object.fromEntries(
-            Object.entries(record).map(([key, value]) => [
-              key,
-              storage.TABLE_SCHEMAS[tableName]?.[key]?.type === "timestamp" ? new Date(value).toISOString() : value
-            ])
-          )
-        })),
-        format: "JSONEachRow",
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${storage.TABLE_EVALS} ${whereClause}`,
+        query_params: {
+          ...agentName ? { var_agent_name: agentName } : {},
+          ...fromDate ? { var_from_date: fromDate.toISOString() } : {},
+          ...toDate ? { var_to_date: toDate.toISOString() } : {}
+        },
+        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 = Number(countData.data?.[0]?.count ?? 0);
+      const currentOffset = page * perPage;
+      const hasMore = currentOffset + perPage < total;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const dataResult = await this.client.query({
+        query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${storage.TABLE_EVALS} ${whereClause} ORDER BY created_at DESC LIMIT {var_limit:UInt32} OFFSET {var_offset:UInt32}`,
+        query_params: {
+          ...agentName ? { var_agent_name: agentName } : {},
+          ...fromDate ? { var_from_date: fromDate.toISOString() } : {},
+          ...toDate ? { var_to_date: toDate.toISOString() } : {},
+          var_limit: perPage || 100,
+          var_offset: currentOffset || 0
+        },
         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
         }
       });
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      const rows = await dataResult.json();
+      return {
+        evals: rows.data.map((row) => this.transformEvalRow(row)),
+        total,
+        page,
+        perPage,
+        hasMore
+      };
+    } catch (error$1) {
+      if (error$1?.message?.includes("no such table") || error$1?.message?.includes("does not exist")) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_EVALS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { agentName: agentName ?? "all", type: type ?? "all" }
+        },
+        error$1
+      );
     }
   }
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters,
-    fromDate,
-    toDate
+};
+var MemoryStorageClickhouse = class extends storage.MemoryStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
   }) {
-    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;
+    try {
+      const messages = [];
+      const limit = storage.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 "${storage.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);
+      }
+      const result = await this.client.query({
+        query: `
+        SELECT 
+            id, 
+            content, 
+            role, 
+            type,
+            toDateTime64(createdAt, 3) as createdAt,
+            thread_id AS "threadId"
+        FROM "${storage.TABLE_MESSAGES}"
+        WHERE thread_id = {threadId:String}
+        AND id NOT IN ({exclude:Array(String)})
+        ORDER BY "createdAt" DESC
+        LIMIT {limit:Int64}
+        `,
+        query_params: {
+          threadId,
+          exclude: messages.map((m) => m.id),
+          limit
+        },
+        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
+        }
       });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        conditions.push(
-          `${key} = {var_col_${key}:${COLUMN_TYPES[storage.TABLE_SCHEMAS.mastra_traces?.[key]?.type ?? "text"]}}`
-        );
-        args[`var_col_${key}`] = value;
+      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 agent.MessageList({ threadId, resourceId }).add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
     }
-    if (fromDate) {
-      conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
-      args.var_from_date = fromDate.getTime() / 1e3;
+  }
+  async saveMessages(args) {
+    const { messages, format = "v1" } = 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`);
+      }
     }
-    if (toDate) {
-      conditions.push(`createdAt <= {var_to_date:DateTime64(3)}`);
-      args.var_to_date = toDate.getTime() / 1e3;
+    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 ${storage.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 ${storage.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 ${storage.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: storage.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: storage.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 agent.MessageList().add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
     }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const result = await this.db.query({
-      query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${storage.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
+  }
+  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 "${storage.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;
       }
-    });
-    if (!result) {
-      return [];
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREAD_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    try {
+      const result = await this.client.query({
+        query: `SELECT 
+          id,
+          "resourceId",
+          title,
+          metadata,
+          toDateTime64(createdAt, 3) as createdAt,
+          toDateTime64(updatedAt, 3) as updatedAt
+        FROM "${storage.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
+      }));
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveThread({ thread }) {
+    try {
+      await this.client.insert({
+        table: storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error$1
+      );
+    }
+  }
+  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: storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: id, title }
+        },
+        error$1
+      );
+    }
+  }
+  async deleteThread({ threadId }) {
+    try {
+      await this.client.command({
+        query: `DELETE FROM "${storage.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 "${storage.TABLE_THREADS}" WHERE id = {var_id:String};`,
+        query_params: { var_id: threadId },
+        clickhouse_settings: {
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_DELETE_THREAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error$1
+      );
+    }
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage = 100 } = args;
+    try {
+      const currentOffset = page * perPage;
+      const countResult = await this.client.query({
+        query: `SELECT count() as total FROM ${storage.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,
+          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 ${storage.TABLE_THREADS}
+              WHERE resourceId = {resourceId:String}
+              ORDER BY createdAt DESC
+              LIMIT {limit:Int64} OFFSET {offset:Int64}
+            `,
+        query_params: {
+          resourceId,
+          limit: perPage,
+          offset: currentOffset
+        },
+        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,
+        hasMore: currentOffset + threads.length < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId, page }
+        },
+        error$1
+      );
+    }
+  }
+  async getMessagesPaginated(args) {
+    try {
+      const { threadId, selectBy, format = "v1" } = args;
+      const page = selectBy?.pagination?.page || 0;
+      const perPageInput = selectBy?.pagination?.perPage;
+      const perPage = perPageInput !== void 0 ? perPageInput : storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 20 });
+      const offset = page * perPage;
+      const dateRange = selectBy?.pagination?.dateRange;
+      const fromDate = dateRange?.start;
+      const toDate = dateRange?.end;
+      const messages = [];
+      if (selectBy?.include?.length) {
+        const include = selectBy.include;
+        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 "${storage.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);
+      }
+      let countQuery = `SELECT count() as total FROM ${storage.TABLE_MESSAGES} WHERE thread_id = {threadId:String}`;
+      const countParams = { threadId };
+      if (fromDate) {
+        countQuery += ` AND createdAt >= parseDateTime64BestEffort({fromDate:String}, 3)`;
+        countParams.fromDate = fromDate.toISOString();
+      }
+      if (toDate) {
+        countQuery += ` AND createdAt <= parseDateTime64BestEffort({toDate:String}, 3)`;
+        countParams.toDate = toDate.toISOString();
+      }
+      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 && messages.length === 0) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const excludeIds = messages.map((m) => m.id);
+      let dataQuery = `
+            SELECT 
+              id,
+              content,
+              role,
+              type,
+              toDateTime64(createdAt, 3) as createdAt,
+              thread_id AS "threadId",
+              resourceId
+            FROM ${storage.TABLE_MESSAGES}
+            WHERE thread_id = {threadId:String}
+          `;
+      const dataParams = { threadId };
+      if (fromDate) {
+        dataQuery += ` AND createdAt >= parseDateTime64BestEffort({fromDate:String}, 3)`;
+        dataParams.fromDate = fromDate.toISOString();
+      }
+      if (toDate) {
+        dataQuery += ` AND createdAt <= parseDateTime64BestEffort({toDate:String}, 3)`;
+        dataParams.toDate = toDate.toISOString();
+      }
+      if (excludeIds.length > 0) {
+        dataQuery += ` AND id NOT IN ({excludeIds:Array(String)})`;
+        dataParams.excludeIds = excludeIds;
+      }
+      if (selectBy?.last) {
+        dataQuery += `
+              ORDER BY createdAt DESC
+              LIMIT {limit:Int64}
+            `;
+        dataParams.limit = perPage;
+      } else {
+        dataQuery += `
+              ORDER BY createdAt ASC
+              LIMIT {limit:Int64} OFFSET {offset:Int64}
+            `;
+        dataParams.limit = perPage;
+        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);
+      messages.push(...paginatedMessages);
+      if (selectBy?.last) {
+        messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      }
+      return {
+        messages: format === "v2" ? messages : messages,
+        total,
+        page,
+        perPage,
+        hasMore: offset + perPage < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_MESSAGES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async updateMessages(args) {
+    const { messages } = args;
+    if (messages.length === 0) {
+      return [];
+    }
+    try {
+      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 ${storage.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",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      const existingRows = await existingResult.json();
+      const existingMessages = transformRows(existingRows.data);
+      if (existingMessages.length === 0) {
+        return [];
+      }
+      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 ${storage.TABLE_MESSAGES}
+                UPDATE ${setClauses.join(", ")}
+                WHERE id = {var_id_${paramIdx}:String}
+              `;
+          console.log("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 ${storage.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 ${storage.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.log("Update not applied correctly, retrying with DELETE + INSERT for message:", id);
+              await this.client.command({
+                query: `DELETE FROM ${storage.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: storage.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 ${storage.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 ${storage.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: storage.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 ${storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messages.map((m) => m.id).join(",") }
+        },
+        error$1
+      );
+    }
+  }
+  async getResourceById({ resourceId }) {
+    try {
+      const result = await this.client.query({
+        query: `SELECT id, workingMemory, metadata, createdAt, updatedAt FROM ${storage.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;
+      }
+      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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_RESOURCE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      await this.client.insert({
+        table: storage.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: {
+          date_time_input_format: "best_effort",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      return resource;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId: resource.id }
+        },
+        error$1
+      );
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    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 });
+      }
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const updateQuery = `
+            ALTER TABLE ${storage.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 ${storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_RESOURCE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error$1
+      );
     }
-    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 storage.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,
@@ -234,25 +1425,25 @@ var ClickhouseStore = class extends storage.MastraStorage {
       }).join(",\n");
       const rowTtl = this.ttl?.[tableName]?.row;
       const sql = tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? `
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          ${["id String"].concat(columns)}
-        )
-        ENGINE = ${TABLE_ENGINES[tableName]}
-        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]}
-        PRIMARY KEY (createdAt, ${tableName === storage.TABLE_EVALS ? "run_id" : "id"})
-        ORDER BY (createdAt, ${tableName === storage.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, ${tableName === storage.TABLE_EVALS ? "run_id" : "id"})
+            ORDER BY (createdAt, ${tableName === storage.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.client.query({
         query: sql,
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
@@ -262,14 +1453,60 @@ var ClickhouseStore = class extends storage.MastraStorage {
           output_format_json_quote_64bit_integers: 0
         }
       });
-    } catch (error) {
-      console.error(`Error creating table ${tableName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_ALTER_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
   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,20 +1516,34 @@ var ClickhouseStore = class extends storage.MastraStorage {
           output_format_json_quote_64bit_integers: 0
         }
       });
-    } catch (error) {
-      console.error(`Error clearing table ${tableName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
+  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",
@@ -303,13 +1554,55 @@ var ClickhouseStore = class extends storage.MastraStorage {
           use_client_time_zone: 1
         }
       });
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      console.log("INSERT RESULT", result);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    const recordsToBeInserted = records.map((record) => ({
+      ...Object.fromEntries(
+        Object.entries(record).map(([key, value]) => [
+          key,
+          storage.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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
   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[storage.TABLE_SCHEMAS[tableName]?.[key]?.type ?? "text"]}}`
@@ -317,8 +1610,10 @@ var ClickhouseStore = class extends storage.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 = storage.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}`,
         query_params: values,
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
@@ -344,25 +1639,58 @@ var ClickhouseStore = class extends storage.MastraStorage {
       }
       const data = transformRow(rows.data[0]);
       return data;
-    } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
     }
   }
-  async getThreadById({ threadId }) {
+};
+var ScoresStorageClickhouse = class extends storage.ScoresStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  transformScoreRow(row) {
+    const scorer = storage.safelyParseJSON(row.scorer);
+    const extractStepResult = storage.safelyParseJSON(row.extractStepResult);
+    const analyzeStepResult = storage.safelyParseJSON(row.analyzeStepResult);
+    const metadata = storage.safelyParseJSON(row.metadata);
+    const input = storage.safelyParseJSON(row.input);
+    const output = storage.safelyParseJSON(row.output);
+    const additionalContext = storage.safelyParseJSON(row.additionalContext);
+    const runtimeContext = storage.safelyParseJSON(row.runtimeContext);
+    const entity = storage.safelyParseJSON(row.entity);
+    return {
+      ...row,
+      scorer,
+      extractStepResult,
+      analyzeStepResult,
+      metadata,
+      input,
+      output,
+      additionalContext,
+      runtimeContext,
+      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 "${storage.TABLE_THREADS}"
-        FINAL
-        WHERE id = {var_id:String}`,
-        query_params: { var_id: threadId },
+      const result = await this.client.query({
+        query: `SELECT * FROM ${storage.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",
@@ -371,299 +1699,510 @@ var ClickhouseStore = class extends storage.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
-      };
-    } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
+      return this.transformScoreRow(resultJson[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scoreId: id }
+        },
+        error$1
+      );
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
+  async saveScore(score) {
     try {
-      const result = await this.db.query({
-        query: `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          toDateTime64(createdAt, 3) as createdAt,
-          toDateTime64(updatedAt, 3) as updatedAt
-        FROM "${storage.TABLE_THREADS}"
-        WHERE "resourceId" = {var_resourceId:String}`,
-        query_params: { var_resourceId: resourceId },
+      const record = {
+        ...score
+      };
+      await this.client.insert({
+        table: storage.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",
-          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
-      }));
-    } catch (error) {
-      console.error(`Error getting threads for resource ${resourceId}:`, error);
-      throw error;
+      return { score };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scoreId: score.id }
+        },
+        error$1
+      );
     }
   }
-  async saveThread({ thread }) {
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
     try {
-      await this.db.insert({
-        table: storage.TABLE_THREADS,
-        values: [
-          {
-            ...thread,
-            createdAt: thread.createdAt.toISOString(),
-            updatedAt: thread.updatedAt.toISOString()
-          }
-        ],
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${storage.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);
+      }
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const offset = pagination.page * pagination.perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${storage.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: pagination.perPage,
+          var_offset: offset
+        },
         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 thread;
-    } catch (error) {
-      console.error("Error saving thread:", error);
-      throw error;
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: total > (pagination.page + 1) * pagination.perPage
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_RUN_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId }
+        },
+        error$1
+      );
     }
   }
-  async updateThread({
-    id,
-    title,
-    metadata
+  async getScoresByScorerId({
+    scorerId,
+    pagination
   }) {
     try {
-      const existingThread = await this.getThreadById({ threadId: id });
-      if (!existingThread) {
-        throw new Error(`Thread ${id} not found`);
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${storage.TABLE_SCORERS} WHERE scorerId = {var_scorerId:String}`,
+        query_params: { var_scorerId: scorerId },
+        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 mergedMetadata = {
-        ...existingThread.metadata,
-        ...metadata
-      };
-      const updatedThread = {
-        ...existingThread,
-        title,
-        metadata: mergedMetadata,
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      await this.db.insert({
-        table: storage.TABLE_THREADS,
-        values: [
-          {
-            ...updatedThread,
-            updatedAt: updatedThread.updatedAt.toISOString()
-          }
-        ],
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const offset = pagination.page * pagination.perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${storage.TABLE_SCORERS} WHERE scorerId = {var_scorerId:String} ORDER BY createdAt DESC LIMIT {var_limit:Int64} OFFSET {var_offset:Int64}`,
+        query_params: {
+          var_scorerId: scorerId,
+          var_limit: pagination.perPage,
+          var_offset: offset
+        },
         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;
-    } catch (error) {
-      console.error("Error updating thread:", error);
-      throw error;
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: total > (pagination.page + 1) * pagination.perPage
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId }
+        },
+        error$1
+      );
     }
   }
-  async deleteThread({ threadId }) {
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
     try {
-      await this.db.command({
-        query: `DELETE FROM "${storage.TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
-        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 ${storage.TABLE_SCORERS} WHERE entityId = {var_entityId:String} AND entityType = {var_entityType:String}`,
+        query_params: { var_entityId: entityId, var_entityType: entityType },
+        format: "JSONEachRow"
       });
-      await this.db.command({
-        query: `DELETE FROM "${storage.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);
+      }
+      if (!total) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const offset = pagination.page * pagination.perPage;
+      const result = await this.client.query({
+        query: `SELECT * FROM ${storage.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: {
+          var_entityId: entityId,
+          var_entityType: entityType,
+          var_limit: pagination.perPage,
+          var_offset: offset
+        },
+        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
         }
       });
-    } catch (error) {
-      console.error("Error deleting thread:", error);
-      throw error;
+      const rows = await result.json();
+      const scores = Array.isArray(rows) ? rows.map((row) => this.transformScoreRow(row)) : [];
+      return {
+        pagination: {
+          total,
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: total > (pagination.page + 1) * pagination.perPage
+        },
+        scores
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { entityId, entityType }
+        },
+        error$1
+      );
     }
   }
-  async getMessages({
-    threadId,
-    resourceId,
-    selectBy,
-    format
-  }) {
-    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 "${storage.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))
-          },
-          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));
-      }
-      const result = await this.db.query({
-        query: `
-        SELECT 
-            id, 
-            content, 
-            role, 
-            type,
-            toDateTime64(createdAt, 3) as createdAt,
-            thread_id AS "threadId"
-        FROM "${storage.TABLE_MESSAGES}"
-        WHERE thread_id = {threadId:String}
-        AND id NOT IN ({exclude:Array(String)})
-        ORDER BY "createdAt" DESC
-        LIMIT {limit:Int64}
-        `,
-        query_params: {
-          threadId,
-          exclude: messages.map((m) => m.id),
-          limit
-        },
+};
+var TracesStorageClickhouse = class extends storage.TracesStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.client = client;
+    this.operations = operations;
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const currentOffset = page * perPage;
+    const queryArgs = {};
+    const conditions = [];
+    if (name) {
+      conditions.push(`name LIKE CONCAT({var_name:String}, '%')`);
+      queryArgs.var_name = name;
+    }
+    if (scope) {
+      conditions.push(`scope = {var_scope:String}`);
+      queryArgs.var_scope = scope;
+    }
+    if (attributes) {
+      Object.entries(attributes).forEach(([key, value]) => {
+        conditions.push(`JSONExtractString(attributes, '${key}') = {var_attr_${key}:String}`);
+        queryArgs[`var_attr_${key}`] = value;
+      });
+    }
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        conditions.push(`${key} = {var_col_${key}:${storage.TABLE_SCHEMAS.mastra_traces?.[key]?.type ?? "text"}}`);
+        queryArgs[`var_col_${key}`] = value;
+      });
+    }
+    if (fromDate) {
+      conditions.push(`createdAt >= parseDateTime64BestEffort({var_from_date:String})`);
+      queryArgs.var_from_date = fromDate.toISOString();
+    }
+    if (toDate) {
+      conditions.push(`createdAt <= parseDateTime64BestEffort({var_to_date:String})`);
+      queryArgs.var_to_date = toDate.toISOString();
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    try {
+      const countResult = await this.client.query({
+        query: `SELECT COUNT(*) as count FROM ${storage.TABLE_TRACES} ${whereClause}`,
+        query_params: queryArgs,
         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 countData = await countResult.json();
+      const total = Number(countData.data?.[0]?.count ?? 0);
+      if (total === 0) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const result = await this.client.query({
+        query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${storage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT {var_limit:UInt32} OFFSET {var_offset:UInt32}`,
+        query_params: { ...queryArgs, var_limit: perPage, var_offset: currentOffset },
+        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 list = new agent.MessageList({ threadId, resourceId }).add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      console.error("Error getting messages:", error);
-      throw error;
+      if (!result) {
+        return {
+          traces: [],
+          total,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const resp = await result.json();
+      const rows = resp.data;
+      const traces = rows.map((row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: storage.safelyParseJSON(row.status),
+        events: storage.safelyParseJSON(row.events),
+        links: storage.safelyParseJSON(row.links),
+        attributes: storage.safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: storage.safelyParseJSON(row.other),
+        createdAt: row.createdAt
+      }));
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
+    } catch (error$1) {
+      if (error$1?.message?.includes("no such table") || error$1?.message?.includes("does not exist")) {
+        return {
+          traces: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: name ?? null,
+            scope: scope ?? null,
+            page,
+            perPage,
+            attributes: attributes ? JSON.stringify(attributes) : null,
+            filters: filters ? JSON.stringify(filters) : null,
+            dateRange: dateRange ? JSON.stringify(dateRange) : null
+          }
+        },
+        error$1
+      );
     }
   }
-  async saveMessages(args) {
-    const { messages, format = "v1" } = args;
-    if (messages.length === 0) return messages;
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes,
+    filters,
+    fromDate,
+    toDate
+  }) {
+    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}:${storage.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 ")}` : "";
     try {
-      const threadId = messages[0]?.threadId;
-      const resourceId = messages[0]?.resourceId;
-      if (!threadId) {
-        throw new Error("Thread ID is required");
-      }
-      const thread = await this.getThreadById({ threadId });
-      if (!thread) {
-        throw new Error(`Thread ${threadId} not found`);
-      }
-      await this.db.insert({
-        table: storage.TABLE_MESSAGES,
-        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 || "v2"
-        })),
+      const result = await this.client.query({
+        query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${storage.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
         }
       });
-      const list = new agent.MessageList({ threadId, resourceId }).add(messages, "memory");
-      if (format === `v2`) return list.get.all.v2();
-      return list.get.all.v1();
-    } catch (error) {
-      console.error("Error saving messages:", error);
-      throw error;
+      if (!result) {
+        return [];
+      }
+      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: storage.safelyParseJSON(row.status),
+        events: storage.safelyParseJSON(row.events),
+        links: storage.safelyParseJSON(row.links),
+        attributes: storage.safelyParseJSON(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: storage.safelyParseJSON(row.other),
+        createdAt: row.createdAt
+      }));
+    } catch (error$1) {
+      if (error$1?.message?.includes("no such table") || error$1?.message?.includes("does not exist")) {
+        return [];
+      }
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: name ?? null,
+            scope: scope ?? null,
+            page,
+            perPage,
+            attributes: attributes ? JSON.stringify(attributes) : null,
+            filters: filters ? JSON.stringify(filters) : null,
+            fromDate: fromDate?.toISOString() ?? null,
+            toDate: toDate?.toISOString() ?? null
+          }
+        },
+        error$1
+      );
     }
   }
+  async batchTraceInsert(args) {
+    await this.operations.batchInsert({ tableName: storage.TABLE_TRACES, records: args.records });
+  }
+};
+var WorkflowsStorageClickhouse = class extends storage.WorkflowsStorage {
+  client;
+  operations;
+  constructor({ client, operations }) {
+    super();
+    this.operations = operations;
+    this.client = client;
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
     snapshot
   }) {
     try {
-      const currentSnapshot = await this.load({
+      const currentSnapshot = await this.operations.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: { workflow_name: workflowName, run_id: runId }
       });
@@ -679,7 +2218,7 @@ var ClickhouseStore = class extends storage.MastraStorage {
         createdAt: now.toISOString(),
         updatedAt: now.toISOString()
       };
-      await this.db.insert({
+      await this.client.insert({
         table: storage.TABLE_WORKFLOW_SNAPSHOT,
         format: "JSONEachRow",
         values: [persisting],
@@ -690,9 +2229,16 @@ var ClickhouseStore = class extends storage.MastraStorage {
           output_format_json_quote_64bit_integers: 0
         }
       });
-    } catch (error) {
-      console.error("Error persisting workflow snapshot:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -700,7 +2246,7 @@ var ClickhouseStore = class extends storage.MastraStorage {
     runId
   }) {
     try {
-      const result = await this.load({
+      const result = await this.operations.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -711,9 +2257,16 @@ var ClickhouseStore = class extends storage.MastraStorage {
         return null;
       }
       return result.snapshot;
-    } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error$1
+      );
     }
   }
   parseWorkflowRun(row) {
@@ -750,7 +2303,7 @@ var ClickhouseStore = class extends storage.MastraStorage {
         values.var_workflow_name = workflowName;
       }
       if (resourceId) {
-        const hasResourceId = await this.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push(`resourceId = {var_resourceId:String}`);
           values.var_resourceId = resourceId;
@@ -771,7 +2324,7 @@ var ClickhouseStore = class extends storage.MastraStorage {
       const offsetClause = offset !== void 0 ? `OFFSET ${offset}` : "";
       let total = 0;
       if (limit !== void 0 && offset !== void 0) {
-        const countResult = await this.db.query({
+        const countResult = await this.client.query({
           query: `SELECT COUNT(*) as count FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""} ${whereClause}`,
           query_params: values,
           format: "JSONEachRow"
@@ -779,21 +2332,21 @@ var ClickhouseStore = class extends storage.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 ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.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 ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
+              ${whereClause}
+              ORDER BY createdAt DESC
+              ${limitClause}
+              ${offsetClause}
+            `,
         query_params: values,
         format: "JSONEachRow"
       });
@@ -803,9 +2356,16 @@ var ClickhouseStore = class extends storage.MastraStorage {
         return this.parseWorkflowRun(row);
       });
       return { runs, total: total || runs.length };
-    } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { workflowName: workflowName ?? "", resourceId: resourceId ?? "" }
+        },
+        error$1
+      );
     }
   }
   async getWorkflowRunById({
@@ -824,18 +2384,18 @@ var ClickhouseStore = class extends storage.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 ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.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 ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
+              ${whereClause}
+            `,
         query_params: values,
         format: "JSONEachRow"
       });
@@ -844,24 +2404,249 @@ var ClickhouseStore = class extends storage.MastraStorage {
         return null;
       }
       return this.parseWorkflowRun(resultJson[0]);
-    } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId: runId ?? "", workflowName: workflowName ?? "" }
+        },
+        error$1
+      );
     }
   }
-  async hasColumn(table, column) {
-    const result = await this.db.query({
-      query: `DESCRIBE TABLE ${table}`,
-      format: "JSONEachRow"
+};
+
+// src/storage/index.ts
+var ClickhouseStore = class extends storage.MastraStorage {
+  db;
+  ttl = {};
+  stores;
+  constructor(config) {
+    super({ name: "ClickhouseStore" });
+    this.db = client.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 legacyEvals = new LegacyEvalsStorageClickhouse({ client: this.db, operations });
+    const traces = new TracesStorageClickhouse({ client: this.db, operations });
+    const memory = new MemoryStorageClickhouse({ client: this.db, operations });
+    this.stores = {
+      operations,
+      workflows,
+      scores,
+      legacyEvals,
+      traces,
+      memory
+    };
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true
+    };
+  }
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  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$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_OPTIMIZE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  async materializeTtl({ tableName }) {
+    try {
+      await this.db.command({
+        query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_MATERIALIZE_TTL_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error$1
+      );
+    }
+  }
+  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 persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert(args) {
+    return this.stores.traces.batchTraceInsert(args);
+  }
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
+  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 getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(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 getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination });
   }
   async close() {
     await this.db.close();
   }
 };
 
-exports.COLUMN_TYPES = COLUMN_TYPES;
 exports.ClickhouseStore = ClickhouseStore;
-exports.TABLE_ENGINES = TABLE_ENGINES;