@mastra/clickhouse 0.0.0-trigger-playground-ui-package-20250506151043 → 0.0.0-tsconfig-compile-20250703214351

package/dist/index.js

@@ -1,4 +1,6 @@
 import { createClient } from '@clickhouse/client';
+import { MessageList } from '@mastra/core/agent';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { TABLE_EVALS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, TABLE_MESSAGES, MastraStorage, TABLE_SCHEMAS } from '@mastra/core/storage';
 
 // src/storage/index.ts
@@ -63,7 +65,12 @@ var ClickhouseStore = class extends MastraStorage {
     const resultValue = JSON.parse(row.result);
     const testInfoValue = row.test_info ? JSON.parse(row.test_info) : void 0;
     if (!resultValue || typeof resultValue !== "object" || !("score" in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
+      throw new MastraError({
+        id: "CLICKHOUSE_STORAGE_INVALID_METRIC_FORMAT",
+        text: `Invalid MetricResult format: ${JSON.stringify(resultValue)}`,
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER
+      });
     }
     return {
       input: row.input,
@@ -78,6 +85,18 @@ var ClickhouseStore = class extends MastraStorage {
       createdAt: row.created_at
     };
   }
+  escape(value) {
+    if (typeof value === "string") {
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value instanceof Date) {
+      return `'${value.toISOString()}'`;
+    }
+    if (value === null || value === void 0) {
+      return "NULL";
+    }
+    return value.toString();
+  }
   async getEvalsByAgentName(agentName, type) {
     try {
       const baseQuery = `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_EVALS} WHERE agent_name = {var_agent_name:String}`;
@@ -98,11 +117,18 @@ var ClickhouseStore = class extends 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")) {
+      if (error?.message?.includes("no such table") || error?.message?.includes("does not exist")) {
         return [];
       }
-      this.logger.error("Failed to get evals for the specified agent: " + error?.message);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_EVALS_BY_AGENT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentName, type: type ?? null }
+        },
+        error
+      );
     }
   }
   async batchInsert({ tableName, records }) {
@@ -126,8 +152,15 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_BATCH_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async getTraces({
@@ -175,48 +208,96 @@ var ClickhouseStore = class extends MastraStorage {
       args.var_to_date = toDate.getTime() / 1e3;
     }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const result = await this.db.query({
-      query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
-      query_params: args,
-      clickhouse_settings: {
-        // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-        date_time_input_format: "best_effort",
-        date_time_output_format: "iso",
-        use_client_time_zone: 1,
-        output_format_json_quote_64bit_integers: 0
+    try {
+      const result = await this.db.query({
+        query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
+        query_params: args,
+        clickhouse_settings: {
+          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+          date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
+          use_client_time_zone: 1,
+          output_format_json_quote_64bit_integers: 0
+        }
+      });
+      if (!result) {
+        return [];
       }
-    });
-    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: 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
-    }));
+      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
+      }));
+    } catch (error) {
+      if (error?.message?.includes("no such table") || error?.message?.includes("does not exist")) {
+        return [];
+      }
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_TRACES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: 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
+      );
+    }
   }
   async optimizeTable({ tableName }) {
-    await this.db.command({
-      query: `OPTIMIZE TABLE ${tableName} FINAL`
-    });
+    try {
+      await this.db.command({
+        query: `OPTIMIZE TABLE ${tableName} FINAL`
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_OPTIMIZE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
   }
   async materializeTtl({ tableName }) {
-    await this.db.command({
-      query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`
-    });
+    try {
+      await this.db.command({
+        query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_MATERIALIZE_TTL_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
   }
   async createTable({
     tableName,
@@ -235,7 +316,6 @@ var ClickhouseStore = class extends MastraStorage {
           ${["id String"].concat(columns)}
         )
         ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
         PRIMARY KEY (createdAt, run_id, workflow_name)
         ORDER BY (createdAt, run_id, workflow_name)
         ${rowTtl ? `TTL toDateTime(${rowTtl.ttlKey ?? "createdAt"}) + INTERVAL ${rowTtl.interval} ${rowTtl.unit}` : ""}
@@ -245,7 +325,6 @@ var ClickhouseStore = class extends MastraStorage {
           ${columns}
         )
         ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
         PRIMARY KEY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
         ORDER BY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
         ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ""}
@@ -262,8 +341,75 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error creating table ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CREATE_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
+    }
+  }
+  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);
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    try {
+      const describeSql = `DESCRIBE TABLE ${tableName}`;
+      const result = await this.db.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.db.query({
+            query: alterSql
+          });
+          this.logger?.debug?.(`Added column ${columnName} to table ${tableName}`);
+        }
+      }
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_ALTER_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async clearTable({ tableName }) {
@@ -279,8 +425,15 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error clearing table ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_CLEAR_TABLE_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async insert({ tableName, record }) {
@@ -303,11 +456,21 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_INSERT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
-  async load({ tableName, keys }) {
+  async load({
+    tableName,
+    keys
+  }) {
     try {
       const keyEntries = Object.entries(keys);
       const conditions = keyEntries.map(
@@ -344,8 +507,15 @@ var ClickhouseStore = class extends MastraStorage {
       const data = transformRow(rows.data[0]);
       return data;
     } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName }
+        },
+        error
+      );
     }
   }
   async getThreadById({ threadId }) {
@@ -382,8 +552,15 @@ var ClickhouseStore = class extends MastraStorage {
         updatedAt: thread.updatedAt
       };
     } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREAD_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
   async getThreadsByResourceId({ resourceId }) {
@@ -416,8 +593,15 @@ var ClickhouseStore = class extends MastraStorage {
         updatedAt: thread.updatedAt
       }));
     } catch (error) {
-      console.error(`Error getting threads for resource ${resourceId}:`, error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_THREADS_BY_RESOURCE_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
     }
   }
   async saveThread({ thread }) {
@@ -441,8 +625,15 @@ var ClickhouseStore = class extends MastraStorage {
       });
       return thread;
     } catch (error) {
-      console.error("Error saving thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: thread.id }
+        },
+        error
+      );
     }
   }
   async updateThread({
@@ -467,15 +658,18 @@ var ClickhouseStore = class extends MastraStorage {
       };
       await this.db.insert({
         table: TABLE_THREADS,
+        format: "JSONEachRow",
         values: [
           {
-            ...updatedThread,
+            id: updatedThread.id,
+            resourceId: updatedThread.resourceId,
+            title: updatedThread.title,
+            metadata: updatedThread.metadata,
+            createdAt: updatedThread.createdAt,
             updatedAt: updatedThread.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
@@ -483,14 +677,21 @@ var ClickhouseStore = class extends MastraStorage {
       });
       return updatedThread;
     } catch (error) {
-      console.error("Error updating thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_UPDATE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: id, title }
+        },
+        error
+      );
     }
   }
   async deleteThread({ threadId }) {
     try {
       await this.db.command({
-        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = '${threadId}';`,
+        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
         query_params: { var_thread_id: threadId },
         clickhouse_settings: {
           output_format_json_quote_64bit_integers: 0
@@ -504,14 +705,26 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error("Error deleting thread:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_DELETE_THREAD_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId }
+        },
+        error
+      );
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
     try {
       const messages = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+      const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
       const include = selectBy?.include || [];
       if (include.length) {
         const includeResult = await this.db.query({
@@ -604,16 +817,27 @@ var ClickhouseStore = class extends MastraStorage {
           }
         }
       });
-      return messages;
+      const list = new 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;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId: resourceId ?? "" }
+        },
+        error
+      );
     }
   }
-  async saveMessages({ messages }) {
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
     if (messages.length === 0) return messages;
     try {
       const threadId = messages[0]?.threadId;
+      const resourceId = messages[0]?.resourceId;
       if (!threadId) {
         throw new Error("Thread ID is required");
       }
@@ -621,28 +845,100 @@ var ClickhouseStore = class extends MastraStorage {
       if (!thread) {
         throw new Error(`Thread ${threadId} not found`);
       }
-      await this.db.insert({
-        table: 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
-        })),
+      const existingResult = await this.db.query({
+        query: `SELECT id, thread_id FROM ${TABLE_MESSAGES} WHERE id IN ({ids:Array(String)})`,
+        query_params: {
+          ids: messages.map((m) => m.id)
+        },
         clickhouse_settings: {
           // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
+          date_time_output_format: "iso",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
-        }
+        },
+        format: "JSONEachRow"
       });
-      return messages;
+      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}::${threadId}`));
+      const toUpdate = messages.filter((m) => existingSet.has(`${m.id}::${threadId}`));
+      const updatePromises = toUpdate.map(
+        (message) => this.db.command({
+          query: `
+      ALTER TABLE ${TABLE_MESSAGES}
+      UPDATE content = {var_content:String}, role = {var_role:String}, type = {var_type: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_id: message.id,
+            var_thread_id: 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 messages
+        this.db.insert({
+          table: TABLE_MESSAGES,
+          format: "JSONEachRow",
+          values: toInsert.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"
+          })),
+          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,
+        // Update thread's updatedAt timestamp
+        this.db.insert({
+          table: TABLE_THREADS,
+          format: "JSONEachRow",
+          values: [
+            {
+              id: thread.id,
+              resourceId: thread.resourceId,
+              title: thread.title,
+              metadata: thread.metadata,
+              createdAt: thread.createdAt,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          ],
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        })
+      ]);
+      const list = new MessageList({ 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;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_SAVE_MESSAGES_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
     }
   }
   async persistWorkflowSnapshot({
@@ -679,8 +975,15 @@ var ClickhouseStore = class extends MastraStorage {
         }
       });
     } catch (error) {
-      console.error("Error persisting workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   async loadWorkflowSnapshot({
@@ -700,8 +1003,15 @@ var ClickhouseStore = class extends MastraStorage {
       }
       return result.snapshot;
     } catch (error) {
-      console.error("Error loading workflow snapshot:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName, runId }
+        },
+        error
+      );
     }
   }
   parseWorkflowRun(row) {
@@ -792,8 +1102,15 @@ var ClickhouseStore = class extends MastraStorage {
       });
       return { runs, total: total || runs.length };
     } catch (error) {
-      console.error("Error getting workflow runs:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_WORKFLOW_RUNS_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { workflowName: workflowName ?? "", resourceId: resourceId ?? "" }
+        },
+        error
+      );
     }
   }
   async getWorkflowRunById({
@@ -833,8 +1150,15 @@ var ClickhouseStore = class extends MastraStorage {
       }
       return this.parseWorkflowRun(resultJson[0]);
     } catch (error) {
-      console.error("Error getting workflow run by ID:", error);
-      throw error;
+      throw new MastraError(
+        {
+          id: "CLICKHOUSE_STORAGE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { runId: runId ?? "", workflowName: workflowName ?? "" }
+        },
+        error
+      );
     }
   }
   async hasColumn(table, column) {
@@ -845,9 +1169,37 @@ var ClickhouseStore = class extends MastraStorage {
     const columns = await result.json();
     return columns.some((c) => c.name === column);
   }
+  async getTracesPaginated(_args) {
+    throw new MastraError({
+      id: "CLICKHOUSE_STORAGE_GET_TRACES_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.USER,
+      text: "Method not implemented."
+    });
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new MastraError({
+      id: "CLICKHOUSE_STORAGE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.USER,
+      text: "Method not implemented."
+    });
+  }
+  async getMessagesPaginated(_args) {
+    throw new MastraError({
+      id: "CLICKHOUSE_STORAGE_GET_MESSAGES_PAGINATED_FAILED",
+      domain: ErrorDomain.STORAGE,
+      category: ErrorCategory.USER,
+      text: "Method not implemented."
+    });
+  }
   async close() {
     await this.db.close();
   }
+  async updateMessages(_args) {
+    this.logger.error("updateMessages is not yet implemented in ClickhouseStore");
+    throw new Error("Method not implemented");
+  }
 };
 
 export { COLUMN_TYPES, ClickhouseStore, TABLE_ENGINES };