@mastra/clickhouse 0.0.0-vector-query-sources-20250516172905 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/src/storage/index.ts

@@ -1,33 +1,34 @@
 import type { ClickHouseClient } from '@clickhouse/client';
 import { createClient } from '@clickhouse/client';
-import type { MetricResult, TestInfo } from '@mastra/core/eval';
-import type { MessageType, StorageThreadType } from '@mastra/core/memory';
-import {
-  MastraStorage,
-  TABLE_EVALS,
-  TABLE_MESSAGES,
-  TABLE_SCHEMAS,
-  TABLE_THREADS,
-  TABLE_TRACES,
-  TABLE_WORKFLOW_SNAPSHOT,
-} from '@mastra/core/storage';
+import type { MastraMessageContentV2 } from '@mastra/core/agent';
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
+import type { MastraMessageV1, MastraMessageV2, StorageThreadType } from '@mastra/core/memory';
+import type { ScoreRowData, ScoringSource } from '@mastra/core/scores';
+import { MastraStorage } from '@mastra/core/storage';
 import type {
+  TABLE_SCHEMAS,
   EvalRow,
+  PaginationInfo,
   StorageColumn,
   StorageGetMessagesArg,
   TABLE_NAMES,
   WorkflowRun,
   WorkflowRuns,
+  StorageGetTracesArg,
+  StorageGetTracesPaginatedArg,
+  StoragePagination,
+  StorageDomains,
+  PaginationArgs,
+  StorageResourceType,
 } from '@mastra/core/storage';
-import type { WorkflowRunState } from '@mastra/core/workflows';
-
-function safelyParseJSON(jsonString: string): any {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return {};
-  }
-}
+import type { Trace } from '@mastra/core/telemetry';
+import type { StepResult, WorkflowRunState } from '@mastra/core/workflows';
+import { LegacyEvalsStorageClickhouse } from './domains/legacy-evals';
+import { MemoryStorageClickhouse } from './domains/memory';
+import { StoreOperationsClickhouse } from './domains/operations';
+import { ScoresStorageClickhouse } from './domains/scores';
+import { TracesStorageClickhouse } from './domains/traces';
+import { WorkflowsStorageClickhouse } from './domains/workflows';
 
 type IntervalUnit =
   | 'NANOSECOND'
@@ -60,47 +61,15 @@ export type ClickhouseConfig = {
   };
 };
 
-export const TABLE_ENGINES: Record<TABLE_NAMES, string> = {
-  [TABLE_MESSAGES]: `MergeTree()`,
-  [TABLE_WORKFLOW_SNAPSHOT]: `ReplacingMergeTree()`,
-  [TABLE_TRACES]: `MergeTree()`,
-  [TABLE_THREADS]: `ReplacingMergeTree()`,
-  [TABLE_EVALS]: `MergeTree()`,
-};
-
-export const COLUMN_TYPES: Record<StorageColumn['type'], string> = {
-  text: 'String',
-  timestamp: 'DateTime64(3)',
-  uuid: 'String',
-  jsonb: 'String',
-  integer: 'Int64',
-  bigint: 'Int64',
-};
-
-function transformRows<R>(rows: any[]): R[] {
-  return rows.map((row: any) => transformRow<R>(row));
-}
-
-function transformRow<R>(row: any): R {
-  if (!row) {
-    return row;
-  }
-
-  if (row.createdAt) {
-    row.createdAt = new Date(row.createdAt);
-  }
-  if (row.updatedAt) {
-    row.updatedAt = new Date(row.updatedAt);
-  }
-  return row;
-}
-
 export class ClickhouseStore extends MastraStorage {
   protected db: ClickHouseClient;
   protected ttl: ClickhouseConfig['ttl'] = {};
 
+  stores: StorageDomains;
+
   constructor(config: ClickhouseConfig) {
     super({ name: 'ClickhouseStore' });
+
     this.db = createClient({
       url: config.url,
       username: config.username,
@@ -113,692 +82,161 @@ export class ClickhouseStore extends MastraStorage {
       },
     });
     this.ttl = config.ttl;
-  }
 
-  private transformEvalRow(row: Record<string, any>): EvalRow {
-    row = transformRow(row);
-    const resultValue = JSON.parse(row.result as string);
-    const testInfoValue = row.test_info ? JSON.parse(row.test_info as string) : undefined;
-
-    if (!resultValue || typeof resultValue !== 'object' || !('score' in resultValue)) {
-      throw new Error(`Invalid MetricResult format: ${JSON.stringify(resultValue)}`);
-    }
+    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(): {
+    selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
+    hasColumn: boolean;
+    createTable: boolean;
+    deleteMessages: boolean;
+  } {
     return {
-      input: row.input as string,
-      output: row.output as string,
-      result: resultValue as MetricResult,
-      agentName: row.agent_name as string,
-      metricName: row.metric_name as string,
-      instructions: row.instructions as string,
-      testInfo: testInfoValue as TestInfo,
-      globalRunId: row.global_run_id as string,
-      runId: row.run_id as string,
-      createdAt: row.created_at as string,
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: false,
     };
   }
 
   async getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]> {
-    try {
-      const baseQuery = `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_EVALS} WHERE agent_name = {var_agent_name:String}`;
-      const typeCondition =
-        type === 'test'
-          ? " AND test_info IS NOT NULL AND JSONExtractString(test_info, 'testPath') IS NOT NULL"
-          : type === 'live'
-            ? " AND (test_info IS NULL OR JSONExtractString(test_info, 'testPath') IS NULL)"
-            : '';
-
-      const result = await this.db.query({
-        query: `${baseQuery}${typeCondition} ORDER BY createdAt DESC`,
-        query_params: { var_agent_name: agentName },
-        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,
-        },
-      });
-
-      if (!result) {
-        return [];
-      }
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
 
-      const rows = await result.json();
-      return rows.data.map((row: any) => this.transformEvalRow(row));
-    } catch (error) {
-      // Handle case where table doesn't exist yet
-      if (error instanceof Error && error.message.includes('no such table')) {
-        return [];
-      }
-      this.logger.error('Failed to get evals for the specified agent: ' + (error as any)?.message);
-      throw error;
-    }
+  async getEvals(
+    options: { agentName?: string; type?: 'test' | 'live' } & PaginationArgs,
+  ): Promise<PaginationInfo & { evals: EvalRow[] }> {
+    return this.stores.legacyEvals.getEvals(options);
   }
 
   async batchInsert({ tableName, records }: { tableName: TABLE_NAMES; records: Record<string, any>[] }): Promise<void> {
-    try {
-      await this.db.insert({
-        table: tableName,
-        values: records.map(record => ({
-          ...Object.fromEntries(
-            Object.entries(record).map(([key, value]) => [
-              key,
-              TABLE_SCHEMAS[tableName as TABLE_NAMES]?.[key]?.type === 'timestamp'
-                ? new Date(value).toISOString()
-                : value,
-            ]),
-          ),
-        })),
-        format: 'JSONEachRow',
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: 'best_effort',
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
-    }
+    await this.stores.operations.batchInsert({ tableName, records });
+    // await this.optimizeTable({ tableName });
   }
 
-  async getTraces({
-    name,
-    scope,
-    page,
-    perPage,
-    attributes,
-    filters,
-    fromDate,
-    toDate,
-  }: {
-    name?: string;
-    scope?: string;
-    page: number;
-    perPage: number;
-    attributes?: Record<string, string>;
-    filters?: Record<string, any>;
-    fromDate?: Date;
-    toDate?: Date;
-  }): Promise<any[]> {
-    const limit = perPage;
-    const offset = page * perPage;
-
-    const args: Record<string, any> = {};
-
-    const conditions: string[] = [];
-    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;
+  async optimizeTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    try {
+      await this.db.command({
+        query: `OPTIMIZE TABLE ${tableName} FINAL`,
       });
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'CLICKHOUSE_STORAGE_OPTIMIZE_TABLE_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName },
+        },
+        error,
+      );
     }
+  }
 
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        conditions.push(
-          `${key} = {var_col_${key}:${COLUMN_TYPES[TABLE_SCHEMAS.mastra_traces?.[key]?.type ?? 'text']}}`,
-        );
-        args[`var_col_${key}`] = value;
+  async materializeTtl({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    try {
+      await this.db.command({
+        query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`,
       });
+    } catch (error: any) {
+      throw new MastraError(
+        {
+          id: 'CLICKHOUSE_STORAGE_MATERIALIZE_TTL_FAILED',
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { tableName },
+        },
+        error,
+      );
     }
-
-    if (fromDate) {
-      conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
-      args.var_from_date = fromDate.getTime() / 1000; // Convert to Unix timestamp
-    }
-
-    if (toDate) {
-      conditions.push(`createdAt <= {var_to_date:DateTime64(3)}`);
-      args.var_to_date = toDate.getTime() / 1000; // Convert to Unix timestamp
-    }
-
-    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,
-      },
-    });
-
-    if (!result) {
-      return [];
-    }
-
-    const resp = await result.json();
-    const rows: any[] = 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 as string),
-      events: safelyParseJSON(row.events as string),
-      links: safelyParseJSON(row.links as string),
-      attributes: safelyParseJSON(row.attributes as string),
-      startTime: row.startTime,
-      endTime: row.endTime,
-      other: safelyParseJSON(row.other as string),
-      createdAt: row.createdAt,
-    }));
   }
 
-  async optimizeTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    await this.db.command({
-      query: `OPTIMIZE TABLE ${tableName} FINAL`,
-    });
+  async createTable({
+    tableName,
+    schema,
+  }: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+  }): Promise<void> {
+    return this.stores.operations.createTable({ tableName, schema });
   }
 
-  async materializeTtl({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    await this.db.command({
-      query: `ALTER TABLE ${tableName} MATERIALIZE TTL;`,
-    });
+  async dropTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
+    return this.stores.operations.dropTable({ tableName });
   }
 
-  async createTable({
+  async alterTable({
     tableName,
     schema,
+    ifNotExists,
   }: {
     tableName: TABLE_NAMES;
     schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
   }): Promise<void> {
-    try {
-      const columns = Object.entries(schema)
-        .map(([name, def]) => {
-          const constraints = [];
-          if (!def.nullable) constraints.push('NOT NULL');
-          const columnTtl = this.ttl?.[tableName]?.columns?.[name];
-          return `"${name}" ${COLUMN_TYPES[def.type]} ${constraints.join(' ')} ${columnTtl ? `TTL toDateTime(${columnTtl.ttlKey ?? 'createdAt'}) + INTERVAL ${columnTtl.interval} ${columnTtl.unit}` : ''}`;
-        })
-        .join(',\n');
-
-      const rowTtl = this.ttl?.[tableName]?.row;
-      const sql =
-        tableName === TABLE_WORKFLOW_SNAPSHOT
-          ? `
-        CREATE TABLE IF NOT EXISTS ${tableName} (
-          ${['id String'].concat(columns)}
-        )
-        ENGINE = ${TABLE_ENGINES[tableName]}
-        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 === TABLE_EVALS ? 'run_id' : 'id'})
-        ORDER BY (createdAt, ${tableName === TABLE_EVALS ? 'run_id' : 'id'})
-        ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ''}
-        SETTINGS index_granularity = 8192
-      `;
-
-      await this.db.query({
-        query: sql,
-        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 creating table ${tableName}:`, error);
-      throw error;
-    }
+    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
   }
 
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
-    try {
-      await this.db.query({
-        query: `TRUNCATE TABLE ${tableName}`,
-        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 clearing table ${tableName}:`, error);
-      throw error;
-    }
+    return this.stores.operations.clearTable({ tableName });
   }
 
   async insert({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): Promise<void> {
-    try {
-      await this.db.insert({
-        table: tableName,
-        values: [
-          {
-            ...record,
-            createdAt: record.createdAt.toISOString(),
-            updatedAt: record.updatedAt.toISOString(),
-          },
-        ],
-        format: 'JSONEachRow',
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          output_format_json_quote_64bit_integers: 0,
-          date_time_input_format: 'best_effort',
-          use_client_time_zone: 1,
-        },
-      });
-    } catch (error) {
-      console.error(`Error inserting into ${tableName}:`, error);
-      throw error;
-    }
+    return this.stores.operations.insert({ tableName, record });
   }
 
   async load<R>({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, string> }): Promise<R | null> {
-    try {
-      const keyEntries = Object.entries(keys);
-      const conditions = keyEntries
-        .map(
-          ([key]) =>
-            `"${key}" = {var_${key}:${COLUMN_TYPES[TABLE_SCHEMAS[tableName as TABLE_NAMES]?.[key]?.type ?? 'text']}}`,
-        )
-        .join(' AND ');
-      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 as TABLE_NAMES].startsWith('ReplacingMergeTree') ? 'FINAL' : ''} WHERE ${conditions}`,
-        query_params: values,
-        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 null;
-      }
-
-      const rows = await result.json();
-      // If this is a workflow snapshot, parse the snapshot field
-      if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-        const snapshot = rows.data[0] as any;
-        if (!snapshot) {
-          return null;
-        }
-        if (typeof snapshot.snapshot === 'string') {
-          snapshot.snapshot = JSON.parse(snapshot.snapshot);
-        }
-        return transformRow(snapshot);
-      }
-
-      const data: R = transformRow(rows.data[0]);
-      return data;
-    } catch (error) {
-      console.error(`Error loading from ${tableName}:`, error);
-      throw error;
-    }
+    return this.stores.operations.load({ tableName, keys });
   }
 
-  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
-    try {
-      const result = await this.db.query({
-        query: `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          toDateTime64(createdAt, 3) as createdAt,
-          toDateTime64(updatedAt, 3) as updatedAt
-        FROM "${TABLE_THREADS}"
-        FINAL
-        WHERE id = {var_id:String}`,
-        query_params: { var_id: threadId },
-        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]) as StorageThreadType;
-
-      if (!thread) {
-        return null;
-      }
-
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt,
-      };
-    } catch (error) {
-      console.error(`Error getting thread ${threadId}:`, error);
-      throw error;
-    }
-  }
-
-  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
-    try {
-      const result = await this.db.query({
-        query: `SELECT 
-          id,
-          "resourceId",
-          title,
-          metadata,
-          toDateTime64(createdAt, 3) as createdAt,
-          toDateTime64(updatedAt, 3) as updatedAt
-        FROM "${TABLE_THREADS}"
-        WHERE "resourceId" = {var_resourceId:String}`,
-        query_params: { var_resourceId: resourceId },
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: 'best_effort',
-          date_time_output_format: 'iso',
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-
-      const rows = await result.json();
-      const threads = transformRows(rows.data) as StorageThreadType[];
-
-      return threads.map((thread: StorageThreadType) => ({
-        ...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;
-    }
-  }
-
-  async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
-    try {
-      await this.db.insert({
-        table: TABLE_THREADS,
-        values: [
-          {
-            ...thread,
-            createdAt: thread.createdAt.toISOString(),
-            updatedAt: thread.updatedAt.toISOString(),
-          },
-        ],
-        format: 'JSONEachRow',
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: 'best_effort',
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-
-      return thread;
-    } catch (error) {
-      console.error('Error saving thread:', error);
-      throw error;
-    }
-  }
-
-  async updateThread({
-    id,
-    title,
-    metadata,
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext,
   }: {
-    id: string;
-    title: string;
-    metadata: Record<string, unknown>;
-  }): Promise<StorageThreadType> {
-    try {
-      // First get the existing thread to merge metadata
-      const existingThread = await this.getThreadById({ threadId: id });
-      if (!existingThread) {
-        throw new Error(`Thread ${id} not found`);
-      }
-
-      // Merge the existing metadata with the new metadata
-      const mergedMetadata = {
-        ...existingThread.metadata,
-        ...metadata,
-      };
-
-      const updatedThread = {
-        ...existingThread,
-        title,
-        metadata: mergedMetadata,
-        updatedAt: new Date(),
-      };
-
-      await this.db.insert({
-        table: TABLE_THREADS,
-        values: [
-          {
-            ...updatedThread,
-            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,
-        },
-      });
-
-      return updatedThread;
-    } catch (error) {
-      console.error('Error updating thread:', error);
-      throw error;
-    }
-  }
-
-  async deleteThread({ threadId }: { threadId: string }): Promise<void> {
-    try {
-      // First delete all messages associated with this thread
-      await this.db.command({
-        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
-        query_params: { var_thread_id: threadId },
-        clickhouse_settings: {
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-
-      // Then delete the thread
-      await this.db.command({
-        query: `DELETE FROM "${TABLE_THREADS}" WHERE id = {var_id:String};`,
-        query_params: { var_id: threadId },
-        clickhouse_settings: {
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-    } catch (error) {
-      console.error('Error deleting thread:', error);
-      throw error;
-    }
-  }
-
-  async getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]> {
-    try {
-      const messages: any[] = [];
-      const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
-      const include = selectBy?.include || [];
-
-      if (include.length) {
-        const includeResult = await this.db.query({
-          query: `
-          WITH ordered_messages AS (
-            SELECT 
-              *,
-              toDateTime64(createdAt, 3) as createdAt,
-              toDateTime64(updatedAt, 3) as updatedAt,
-              ROW_NUMBER() OVER (ORDER BY "createdAt" DESC) as row_num
-            FROM "${TABLE_MESSAGES}"
-            WHERE thread_id = {var_thread_id:String}
-          )
-          SELECT
-            m.id AS id, 
-            m.content as content, 
-            m.role as role, 
-            m.type as type,
-            m.createdAt as createdAt, 
-            m.updatedAt as updatedAt,
-            m.thread_id AS "threadId"
-          FROM ordered_messages m
-          WHERE m.id = ANY({var_include:Array(String)})
-          OR EXISTS (
-            SELECT 1 FROM ordered_messages target
-            WHERE target.id = ANY({var_include:Array(String)})
-            AND (
-              -- Get previous messages based on the max withPreviousMessages
-              (m.row_num <= target.row_num + {var_withPreviousMessages:Int64} AND m.row_num > target.row_num)
-              OR
-              -- Get next messages based on the max withNextMessages
-              (m.row_num >= target.row_num - {var_withNextMessages:Int64} AND m.row_num < target.row_num)
-            )
-          )
-          ORDER BY m."createdAt" DESC
-          `,
-          query_params: {
-            var_thread_id: threadId,
-            var_include: include.map(i => i.id),
-            var_withPreviousMessages: Math.max(...include.map(i => i.withPreviousMessages || 0)),
-            var_withNextMessages: Math.max(...include.map(i => i.withNextMessages || 0)),
-          },
-          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 includeResult.json();
-        messages.push(...transformRows(rows.data));
-      }
-
-      // Then get the remaining messages, excluding the ids we just fetched
-      const result = await this.db.query({
-        query: `
-        SELECT 
-            id, 
-            content, 
-            role, 
-            type,
-            toDateTime64(createdAt, 3) as createdAt,
-            thread_id AS "threadId"
-        FROM "${TABLE_MESSAGES}"
-        WHERE thread_id = {threadId:String}
-        AND id NOT IN ({exclude:Array(String)})
-        ORDER BY "createdAt" DESC
-        LIMIT {limit:Int64}
-        `,
-        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,
-        },
-      });
-
-      const rows = await result.json();
-      messages.push(...transformRows(rows.data));
-
-      // Sort all messages by creation date
-      messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-
-      // Parse message content
-      messages.forEach(message => {
-        if (typeof message.content === 'string') {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-            // If parsing fails, leave as string
-          }
-        }
-      });
-
-      return messages as T[];
-    } catch (error) {
-      console.error('Error getting messages:', error);
-      throw error;
-    }
+    workflowName: string;
+    runId: string;
+    stepId: string;
+    result: StepResult<any, any, any, any>;
+    runtimeContext: Record<string, any>;
+  }): Promise<Record<string, StepResult<any, any, any, any>>> {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
   }
 
-  async saveMessages({ messages }: { messages: MessageType[] }): Promise<MessageType[]> {
-    if (messages.length === 0) return messages;
-
-    try {
-      const threadId = messages[0]?.threadId;
-      if (!threadId) {
-        throw new Error('Thread ID is required');
-      }
-
-      // Check if thread exists
-      const thread = await this.getThreadById({ threadId });
-      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,
-        })),
-        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 messages;
-    } catch (error) {
-      console.error('Error saving messages:', error);
-      throw error;
-    }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts,
+  }: {
+    workflowName: string;
+    runId: string;
+    opts: {
+      status: string;
+      result?: StepResult<any, any, any, any>;
+      error?: string;
+      suspendedPaths?: Record<string, number[]>;
+      waitingPaths?: Record<string, number[]>;
+    };
+  }): Promise<WorkflowRunState | undefined> {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
   }
 
   async persistWorkflowSnapshot({
@@ -810,42 +248,7 @@ export class ClickhouseStore extends MastraStorage {
     runId: string;
     snapshot: WorkflowRunState;
   }): Promise<void> {
-    try {
-      const currentSnapshot = await this.load({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        keys: { workflow_name: workflowName, run_id: runId },
-      });
-
-      const now = new Date();
-      const persisting = currentSnapshot
-        ? {
-            ...currentSnapshot,
-            snapshot: JSON.stringify(snapshot),
-            updatedAt: now.toISOString(),
-          }
-        : {
-            workflow_name: workflowName,
-            run_id: runId,
-            snapshot: JSON.stringify(snapshot),
-            createdAt: now.toISOString(),
-            updatedAt: now.toISOString(),
-          };
-
-      await this.db.insert({
-        table: TABLE_WORKFLOW_SNAPSHOT,
-        format: 'JSONEachRow',
-        values: [persisting],
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: 'best_effort',
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0,
-        },
-      });
-    } catch (error) {
-      console.error('Error persisting workflow snapshot:', error);
-      throw error;
-    }
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
   }
 
   async loadWorkflowSnapshot({
@@ -855,45 +258,7 @@ export class ClickhouseStore extends MastraStorage {
     workflowName: string;
     runId: string;
   }): Promise<WorkflowRunState | null> {
-    try {
-      const result = await this.load({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId,
-        },
-      });
-
-      if (!result) {
-        return null;
-      }
-
-      return (result as any).snapshot;
-    } catch (error) {
-      console.error('Error loading workflow snapshot:', error);
-      throw error;
-    }
-  }
-
-  private parseWorkflowRun(row: any): WorkflowRun {
-    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
-    if (typeof parsedSnapshot === 'string') {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
-      } catch (e) {
-        // If parsing fails, return the raw snapshot string
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-      resourceId: row.resourceId,
-    };
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
 
   async getWorkflowRuns({
@@ -911,143 +276,178 @@ export class ClickhouseStore extends MastraStorage {
     offset?: number;
     resourceId?: string;
   } = {}): Promise<WorkflowRuns> {
-    try {
-      const conditions: string[] = [];
-      const values: Record<string, any> = {};
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
 
-      if (workflowName) {
-        conditions.push(`workflow_name = {var_workflow_name:String}`);
-        values.var_workflow_name = workflowName;
-      }
+  async getWorkflowRunById({
+    runId,
+    workflowName,
+  }: {
+    runId: string;
+    workflowName?: string;
+  }): Promise<WorkflowRun | null> {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
 
-      if (resourceId) {
-        const hasResourceId = await this.hasColumn(TABLE_WORKFLOW_SNAPSHOT, 'resourceId');
-        if (hasResourceId) {
-          conditions.push(`resourceId = {var_resourceId:String}`);
-          values.var_resourceId = resourceId;
-        } else {
-          console.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
-        }
-      }
+  async getTraces(args: StorageGetTracesArg): Promise<any[]> {
+    return this.stores.traces.getTraces(args);
+  }
 
-      if (fromDate) {
-        conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
-        values.var_from_date = fromDate.getTime() / 1000; // Convert to Unix timestamp
-      }
+  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
+    return this.stores.traces.getTracesPaginated(args);
+  }
 
-      if (toDate) {
-        conditions.push(`createdAt <= {var_to_date:DateTime64(3)}`);
-        values.var_to_date = toDate.getTime() / 1000; // Convert to Unix timestamp
-      }
+  async batchTraceInsert(args: { records: Trace[] }): Promise<void> {
+    return this.stores.traces.batchTraceInsert(args);
+  }
 
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-      const limitClause = limit !== undefined ? `LIMIT ${limit}` : '';
-      const offsetClause = offset !== undefined ? `OFFSET ${offset}` : '';
+  async getThreadById({ threadId }: { threadId: string }): Promise<StorageThreadType | null> {
+    return this.stores.memory.getThreadById({ threadId });
+  }
 
-      let total = 0;
-      // Only get total count when using pagination
-      if (limit !== undefined && offset !== undefined) {
-        const countResult = await this.db.query({
-          query: `SELECT COUNT(*) as count FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith('ReplacingMergeTree') ? 'FINAL' : ''} ${whereClause}`,
-          query_params: values,
-          format: 'JSONEachRow',
-        });
-        const countRows = await countResult.json();
-        total = Number((countRows as Array<{ count: string | number }>)[0]?.count ?? 0);
-      }
+  async getThreadsByResourceId({ resourceId }: { resourceId: string }): Promise<StorageThreadType[]> {
+    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  }
 
-      // Get results
-      const result = await this.db.query({
-        query: `
-          SELECT 
-            workflow_name,
-            run_id,
-            snapshot,
-            toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt,
-            resourceId
-          FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith('ReplacingMergeTree') ? 'FINAL' : ''}
-          ${whereClause}
-          ORDER BY createdAt DESC
-          ${limitClause}
-          ${offsetClause}
-        `,
-        query_params: values,
-        format: 'JSONEachRow',
-      });
+  async saveThread({ thread }: { thread: StorageThreadType }): Promise<StorageThreadType> {
+    return this.stores.memory.saveThread({ thread });
+  }
 
-      const resultJson = await result.json();
-      const rows = resultJson as any[];
-      const runs = rows.map(row => {
-        return this.parseWorkflowRun(row);
-      });
+  async updateThread({
+    id,
+    title,
+    metadata,
+  }: {
+    id: string;
+    title: string;
+    metadata: Record<string, unknown>;
+  }): Promise<StorageThreadType> {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
 
-      // Use runs.length as total when not paginating
-      return { runs, total: total || runs.length };
-    } catch (error) {
-      console.error('Error getting workflow runs:', error);
-      throw error;
-    }
+  async deleteThread({ threadId }: { threadId: string }): Promise<void> {
+    return this.stores.memory.deleteThread({ threadId });
   }
 
-  async getWorkflowRunById({
-    runId,
-    workflowName,
+  async getThreadsByResourceIdPaginated(args: {
+    resourceId: string;
+    page: number;
+    perPage: number;
+  }): Promise<PaginationInfo & { threads: StorageThreadType[] }> {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+
+  public async getMessages(args: StorageGetMessagesArg & { format?: 'v1' }): Promise<MastraMessageV1[]>;
+  public async getMessages(args: StorageGetMessagesArg & { format: 'v2' }): Promise<MastraMessageV2[]>;
+  public async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format,
+  }: StorageGetMessagesArg & { format?: 'v1' | 'v2' }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
+    return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
+  }
+
+  async getMessagesById({ messageIds, format }: { messageIds: string[]; format: 'v1' }): Promise<MastraMessageV1[]>;
+  async getMessagesById({ messageIds, format }: { messageIds: string[]; format?: 'v2' }): Promise<MastraMessageV2[]>;
+  async getMessagesById({
+    messageIds,
+    format,
   }: {
-    runId: string;
-    workflowName?: string;
-  }): Promise<WorkflowRun | null> {
-    try {
-      const conditions: string[] = [];
-      const values: Record<string, any> = {};
+    messageIds: string[];
+    format?: 'v1' | 'v2';
+  }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
 
-      if (runId) {
-        conditions.push(`run_id = {var_runId:String}`);
-        values.var_runId = runId;
-      }
+  async saveMessages(args: { messages: MastraMessageV1[]; format?: undefined | 'v1' }): Promise<MastraMessageV1[]>;
+  async saveMessages(args: { messages: MastraMessageV2[]; format: 'v2' }): Promise<MastraMessageV2[]>;
+  async saveMessages(
+    args: { messages: MastraMessageV1[]; format?: undefined | 'v1' } | { messages: MastraMessageV2[]; format: 'v2' },
+  ): Promise<MastraMessageV2[] | MastraMessageV1[]> {
+    return this.stores.memory.saveMessages(args);
+  }
 
-      if (workflowName) {
-        conditions.push(`workflow_name = {var_workflow_name:String}`);
-        values.var_workflow_name = workflowName;
-      }
+  async getMessagesPaginated(
+    args: StorageGetMessagesArg & { format?: 'v1' | 'v2' },
+  ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
 
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+  async updateMessages(args: {
+    messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+      id: string;
+      threadId?: string;
+      content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
+    })[];
+  }): Promise<MastraMessageV2[]> {
+    return this.stores.memory.updateMessages(args);
+  }
 
-      // Get results
-      const result = await this.db.query({
-        query: `
-          SELECT 
-            workflow_name,
-            run_id,
-            snapshot,
-            toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt,
-            resourceId
-          FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith('ReplacingMergeTree') ? 'FINAL' : ''}
-          ${whereClause}
-        `,
-        query_params: values,
-        format: 'JSONEachRow',
-      });
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
 
-      const resultJson = await result.json();
-      if (!Array.isArray(resultJson) || resultJson.length === 0) {
-        return null;
-      }
-      return this.parseWorkflowRun(resultJson[0]);
-    } catch (error) {
-      console.error('Error getting workflow run by ID:', error);
-      throw error;
-    }
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    return this.stores.memory.saveResource({ resource });
   }
 
-  private async hasColumn(table: string, column: string): Promise<boolean> {
-    const result = await this.db.query({
-      query: `DESCRIBE TABLE ${table}`,
-      format: 'JSONEachRow',
-    });
-    const columns = (await result.json()) as { name: string }[];
-    return columns.some(c => c.name === column);
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+
+  async getScoreById({ id }: { id: string }): Promise<ScoreRowData | null> {
+    return this.stores.scores.getScoreById({ id });
+  }
+
+  async saveScore(_score: ScoreRowData): Promise<{ score: ScoreRowData }> {
+    return this.stores.scores.saveScore(_score);
+  }
+
+  async getScoresByRunId({
+    runId,
+    pagination,
+  }: {
+    runId: string;
+    pagination: StoragePagination;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByRunId({ runId, pagination });
+  }
+
+  async getScoresByEntityId({
+    entityId,
+    entityType,
+    pagination,
+  }: {
+    pagination: StoragePagination;
+    entityId: string;
+    entityType: string;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByEntityId({ entityId, entityType, pagination });
+  }
+
+  async getScoresByScorerId({
+    scorerId,
+    pagination,
+    entityId,
+    entityType,
+    source,
+  }: {
+    scorerId: string;
+    pagination: StoragePagination;
+    entityId?: string;
+    entityType?: string;
+    source?: ScoringSource;
+  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
+    return this.stores.scores.getScoresByScorerId({ scorerId, pagination, entityId, entityType, source });
   }
 
   async close(): Promise<void> {