@mastra/lance 0.2.10 → 0.2.11-alpha.0

package/src/storage/domains/scores/index.ts

@@ -1,243 +0,0 @@
-import type { Connection } from '@lancedb/lancedb';
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { ScoreRowData, ScoringSource } from '@mastra/core/scores';
-import { ScoresStorage, TABLE_SCORERS } from '@mastra/core/storage';
-import type { PaginationInfo, StoragePagination } from '@mastra/core/storage';
-import { getTableSchema, processResultWithTypeConversion } from '../utils';
-
-export class StoreScoresLance extends ScoresStorage {
-  private client: Connection;
-  constructor({ client }: { client: Connection }) {
-    super();
-    this.client = client;
-  }
-
-  async saveScore(score: ScoreRowData): Promise<{ score: ScoreRowData }> {
-    try {
-      const id = crypto.randomUUID();
-      const table = await this.client.openTable(TABLE_SCORERS);
-      // Fetch schema fields for mastra_scorers
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const allowedFields = new Set(schema.fields.map((f: any) => f.name));
-      // Filter out fields not in schema
-      const filteredScore: Record<string, any> = {};
-      (Object.keys(score) as (keyof ScoreRowData)[]).forEach(key => {
-        if (allowedFields.has(key)) {
-          filteredScore[key] = score[key];
-        }
-      });
-      // Convert any object fields to JSON strings for storage
-      for (const key in filteredScore) {
-        if (
-          filteredScore[key] !== null &&
-          typeof filteredScore[key] === 'object' &&
-          !(filteredScore[key] instanceof Date)
-        ) {
-          filteredScore[key] = JSON.stringify(filteredScore[key]);
-        }
-      }
-
-      filteredScore.id = id;
-      await table.add([filteredScore], { mode: 'append' });
-      return { score };
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORAGE_SAVE_SCORE_FAILED',
-          text: 'Failed to save score in LanceStorage',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { error: error?.message },
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoreById({ id }: { id: string }): Promise<ScoreRowData | null> {
-    try {
-      const table = await this.client.openTable(TABLE_SCORERS);
-
-      const query = table.query().where(`id = '${id}'`).limit(1);
-
-      const records = await query.toArray();
-
-      if (records.length === 0) return null;
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      return processResultWithTypeConversion(records[0], schema) as ScoreRowData;
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORAGE_GET_SCORE_BY_ID_FAILED',
-          text: 'Failed to get score by id in LanceStorage',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { error: error?.message },
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoresByScorerId({
-    scorerId,
-    pagination,
-    entityId,
-    entityType,
-    source,
-  }: {
-    scorerId: string;
-    pagination: StoragePagination;
-    entityId?: string;
-    entityType?: string;
-    source?: ScoringSource;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const table = await this.client.openTable(TABLE_SCORERS);
-      // Use zero-based pagination (default page = 0)
-      const { page = 0, perPage = 10 } = pagination || {};
-      const offset = page * perPage;
-
-      let query = table.query().where(`\`scorerId\` = '${scorerId}'`);
-
-      if (source) {
-        query = query.where(`\`source\` = '${source}'`);
-      }
-
-      if (entityId) {
-        query = query.where(`\`entityId\` = '${entityId}'`);
-      }
-      if (entityType) {
-        query = query.where(`\`entityType\` = '${entityType}'`);
-      }
-
-      query = query.limit(perPage);
-      if (offset > 0) query.offset(offset);
-      const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema) as ScoreRowData[];
-
-      let totalQuery = table.query().where(`\`scorerId\` = '${scorerId}'`);
-      if (source) {
-        totalQuery = totalQuery.where(`\`source\` = '${source}'`);
-      }
-      const allRecords = await totalQuery.toArray();
-      const total = allRecords.length;
-
-      return {
-        pagination: {
-          page,
-          perPage,
-          total,
-          hasMore: offset + scores.length < total,
-        },
-        scores,
-      };
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORAGE_GET_SCORES_BY_SCORER_ID_FAILED',
-          text: 'Failed to get scores by scorerId in LanceStorage',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { error: error?.message },
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoresByRunId({
-    runId,
-    pagination,
-  }: {
-    runId: string;
-    pagination: StoragePagination;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const table = await this.client.openTable(TABLE_SCORERS);
-      const { page = 0, perPage = 10 } = pagination || {};
-      const offset = page * perPage;
-      // Query for scores with the given runId
-      const query = table.query().where(`\`runId\` = '${runId}'`).limit(perPage);
-      if (offset > 0) query.offset(offset);
-      const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema) as ScoreRowData[];
-      // Get total count for pagination
-      const allRecords = await table.query().where(`\`runId\` = '${runId}'`).toArray();
-      const total = allRecords.length;
-      return {
-        pagination: {
-          page,
-          perPage,
-          total,
-          hasMore: offset + scores.length < total,
-        },
-        scores,
-      };
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORAGE_GET_SCORES_BY_RUN_ID_FAILED',
-          text: 'Failed to get scores by runId in LanceStorage',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { error: error?.message },
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoresByEntityId({
-    entityId,
-    entityType,
-    pagination,
-  }: {
-    pagination: StoragePagination;
-    entityId: string;
-    entityType: string;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const table = await this.client.openTable(TABLE_SCORERS);
-      const { page = 0, perPage = 10 } = pagination || {};
-      const offset = page * perPage;
-      // Query for scores with the given entityId and entityType
-      const query = table
-        .query()
-        .where(`\`entityId\` = '${entityId}' AND \`entityType\` = '${entityType}'`)
-        .limit(perPage);
-      if (offset > 0) query.offset(offset);
-      const records = await query.toArray();
-      const schema = await getTableSchema({ tableName: TABLE_SCORERS, client: this.client });
-      const scores = processResultWithTypeConversion(records, schema) as ScoreRowData[];
-      // Get total count for pagination
-      const allRecords = await table
-        .query()
-        .where(`\`entityId\` = '${entityId}' AND \`entityType\` = '${entityType}'`)
-        .toArray();
-      const total = allRecords.length;
-      return {
-        pagination: {
-          page,
-          perPage,
-          total,
-          hasMore: offset + scores.length < total,
-        },
-        scores,
-      };
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORAGE_GET_SCORES_BY_ENTITY_ID_FAILED',
-          text: 'Failed to get scores by entityId and entityType in LanceStorage',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { error: error?.message },
-        },
-        error,
-      );
-    }
-  }
-}

package/src/storage/domains/traces/index.ts

@@ -1,212 +0,0 @@
-import type { Connection } from '@lancedb/lancedb';
-import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
-import type { TraceType } from '@mastra/core/memory';
-import { TABLE_TRACES, TracesStorage } from '@mastra/core/storage';
-import type { PaginationInfo, StorageGetTracesPaginatedArg } from '@mastra/core/storage';
-import type { Trace } from '@mastra/core/telemetry';
-import type { StoreOperationsLance } from '../operations';
-
-export class StoreTracesLance extends TracesStorage {
-  private client: Connection;
-  private operations: StoreOperationsLance;
-  constructor({ client, operations }: { client: Connection; operations: StoreOperationsLance }) {
-    super();
-    this.client = client;
-    this.operations = operations;
-  }
-
-  async saveTrace({ trace }: { trace: TraceType }): Promise<TraceType> {
-    try {
-      const table = await this.client.openTable(TABLE_TRACES);
-      const record = {
-        ...trace,
-        attributes: JSON.stringify(trace.attributes),
-        status: JSON.stringify(trace.status),
-        events: JSON.stringify(trace.events),
-        links: JSON.stringify(trace.links),
-        other: JSON.stringify(trace.other),
-      };
-      await table.add([record], { mode: 'append' });
-      return trace;
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORE_SAVE_TRACE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async getTraceById({ traceId }: { traceId: string }): Promise<TraceType> {
-    try {
-      const table = await this.client.openTable(TABLE_TRACES);
-      const query = table.query().where(`id = '${traceId}'`);
-      const records = await query.toArray();
-      return records[0] as TraceType;
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORE_GET_TRACE_BY_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async getTraces({
-    name,
-    scope,
-    page = 1,
-    perPage = 10,
-    attributes,
-  }: {
-    name?: string;
-    scope?: string;
-    page: number;
-    perPage: number;
-    attributes?: Record<string, string>;
-  }): Promise<Trace[]> {
-    try {
-      const table = await this.client.openTable(TABLE_TRACES);
-      const query = table.query();
-      if (name) {
-        query.where(`name = '${name}'`);
-      }
-      if (scope) {
-        query.where(`scope = '${scope}'`);
-      }
-      if (attributes) {
-        query.where(`attributes = '${JSON.stringify(attributes)}'`);
-      }
-      // Calculate offset based on page and perPage
-      const offset = (page - 1) * perPage;
-      query.limit(perPage);
-      if (offset > 0) {
-        query.offset(offset);
-      }
-      const records = await query.toArray();
-      return records.map(record => {
-        const processed = {
-          ...record,
-          attributes: record.attributes ? JSON.parse(record.attributes) : {},
-          status: record.status ? JSON.parse(record.status) : {},
-          events: record.events ? JSON.parse(record.events) : [],
-          links: record.links ? JSON.parse(record.links) : [],
-          other: record.other ? JSON.parse(record.other) : {},
-          startTime: new Date(record.startTime),
-          endTime: new Date(record.endTime),
-          createdAt: new Date(record.createdAt),
-        };
-        if (processed.parentSpanId === null || processed.parentSpanId === undefined) {
-          processed.parentSpanId = '';
-        } else {
-          processed.parentSpanId = String(processed.parentSpanId);
-        }
-        return processed as Trace;
-      });
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORE_GET_TRACES_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { name: name ?? '', scope: scope ?? '' },
-        },
-        error,
-      );
-    }
-  }
-
-  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    try {
-      const table = await this.client.openTable(TABLE_TRACES);
-      const query = table.query();
-      const conditions: string[] = [];
-      if (args.name) {
-        conditions.push(`name = '${args.name}'`);
-      }
-      if (args.scope) {
-        conditions.push(`scope = '${args.scope}'`);
-      }
-      if (args.attributes) {
-        const attributesStr = JSON.stringify(args.attributes);
-        conditions.push(`attributes LIKE '%${attributesStr.replace(/"/g, '\\"')}%'`);
-      }
-      if (args.dateRange?.start) {
-        conditions.push(`\`createdAt\` >= ${args.dateRange.start.getTime()}`);
-      }
-      if (args.dateRange?.end) {
-        conditions.push(`\`createdAt\` <= ${args.dateRange.end.getTime()}`);
-      }
-      if (conditions.length > 0) {
-        const whereClause = conditions.join(' AND ');
-        query.where(whereClause);
-      }
-      let total = 0;
-      if (conditions.length > 0) {
-        const countQuery = table.query().where(conditions.join(' AND '));
-        const allRecords = await countQuery.toArray();
-        total = allRecords.length;
-      } else {
-        total = await table.countRows();
-      }
-      const page = args.page || 0;
-      const perPage = args.perPage || 10;
-      const offset = page * perPage;
-      query.limit(perPage);
-      if (offset > 0) {
-        query.offset(offset);
-      }
-      const records = await query.toArray();
-      const traces = records.map(record => {
-        const processed = {
-          ...record,
-          attributes: record.attributes ? JSON.parse(record.attributes) : {},
-          status: record.status ? JSON.parse(record.status) : {},
-          events: record.events ? JSON.parse(record.events) : [],
-          links: record.links ? JSON.parse(record.links) : [],
-          other: record.other ? JSON.parse(record.other) : {},
-          startTime: new Date(record.startTime),
-          endTime: new Date(record.endTime),
-          createdAt: new Date(record.createdAt),
-        };
-        if (processed.parentSpanId === null || processed.parentSpanId === undefined) {
-          processed.parentSpanId = '';
-        } else {
-          processed.parentSpanId = String(processed.parentSpanId);
-        }
-        return processed as Trace;
-      });
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: total > (page + 1) * perPage,
-      };
-    } catch (error: any) {
-      throw new MastraError(
-        {
-          id: 'LANCE_STORE_GET_TRACES_PAGINATED_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-          details: { name: args.name ?? '', scope: args.scope ?? '' },
-        },
-        error,
-      );
-    }
-  }
-
-  async batchTraceInsert({ records }: { records: Record<string, any>[] }): Promise<void> {
-    this.logger.debug('Batch inserting traces', { count: records.length });
-    await this.operations.batchInsert({
-      tableName: TABLE_TRACES,
-      records,
-    });
-  }
-}

package/src/storage/domains/utils.ts

@@ -1,158 +0,0 @@
-import type { Connection, FieldLike, SchemaLike } from '@lancedb/lancedb';
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import { TABLE_EVALS, TABLE_WORKFLOW_SNAPSHOT } from '@mastra/core/storage';
-import type { TABLE_NAMES } from '@mastra/core/storage';
-
-export function getPrimaryKeys(tableName: TABLE_NAMES): string[] {
-  let primaryId: string[] = ['id'];
-  if (tableName === TABLE_WORKFLOW_SNAPSHOT) {
-    primaryId = ['workflow_name', 'run_id'];
-  } else if (tableName === TABLE_EVALS) {
-    primaryId = ['agent_name', 'metric_name', 'run_id'];
-  }
-
-  return primaryId;
-}
-
-export function validateKeyTypes(keys: Record<string, any>, tableSchema: SchemaLike): void {
-  // Create a map of field names to their expected types
-  const fieldTypes = new Map(
-    tableSchema.fields.map((field: any) => [field.name, field.type?.toString().toLowerCase()]),
-  );
-
-  for (const [key, value] of Object.entries(keys)) {
-    const fieldType = fieldTypes.get(key);
-
-    if (!fieldType) {
-      throw new Error(`Field '${key}' does not exist in table schema`);
-    }
-
-    // Type validation
-    if (value !== null) {
-      if ((fieldType.includes('int') || fieldType.includes('bigint')) && typeof value !== 'number') {
-        throw new Error(`Expected numeric value for field '${key}', got ${typeof value}`);
-      }
-
-      if (fieldType.includes('utf8') && typeof value !== 'string') {
-        throw new Error(`Expected string value for field '${key}', got ${typeof value}`);
-      }
-
-      if (fieldType.includes('timestamp') && !(value instanceof Date) && typeof value !== 'string') {
-        throw new Error(`Expected Date or string value for field '${key}', got ${typeof value}`);
-      }
-    }
-  }
-}
-
-export function processResultWithTypeConversion(
-  rawResult: Record<string, any> | Record<string, any>[],
-  tableSchema: SchemaLike,
-): Record<string, any> | Record<string, any>[] {
-  // Build a map of field names to their schema types
-  const fieldTypeMap = new Map();
-  tableSchema.fields.forEach((field: any) => {
-    const fieldName = field.name;
-    const fieldTypeStr = field.type.toString().toLowerCase();
-    fieldTypeMap.set(fieldName, fieldTypeStr);
-  });
-
-  // Handle array case
-  if (Array.isArray(rawResult)) {
-    return rawResult.map(item => processResultWithTypeConversion(item, tableSchema));
-  }
-
-  // Handle single record case
-  const processedResult = { ...rawResult };
-
-  // Convert each field according to its schema type
-  for (const key in processedResult) {
-    const fieldTypeStr = fieldTypeMap.get(key);
-    if (!fieldTypeStr) continue;
-
-    // Skip conversion for ID fields - preserve their original format
-    // if (key === 'id') {
-    //   continue;
-    // }
-
-    // Only try to convert string values
-    if (typeof processedResult[key] === 'string') {
-      // Numeric types
-      if (fieldTypeStr.includes('int32') || fieldTypeStr.includes('float32')) {
-        if (!isNaN(Number(processedResult[key]))) {
-          processedResult[key] = Number(processedResult[key]);
-        }
-      } else if (fieldTypeStr.includes('int64')) {
-        processedResult[key] = Number(processedResult[key]);
-      } else if (fieldTypeStr.includes('utf8') && key !== 'id') {
-        try {
-          const parsed = JSON.parse(processedResult[key]);
-          if (typeof parsed === 'object') {
-            processedResult[key] = JSON.parse(processedResult[key]);
-          }
-        } catch {}
-      }
-    } else if (typeof processedResult[key] === 'bigint') {
-      // Convert BigInt values to regular numbers for application layer
-      processedResult[key] = Number(processedResult[key]);
-    } else if (fieldTypeStr.includes('float64') && ['createdAt', 'updatedAt'].includes(key)) {
-      processedResult[key] = new Date(processedResult[key]);
-    }
-
-    console.log(key, 'processedResult', processedResult);
-  }
-
-  return processedResult;
-}
-
-export async function getTableSchema({
-  tableName,
-  client,
-}: {
-  tableName: TABLE_NAMES;
-  client: Connection;
-}): Promise<SchemaLike> {
-  try {
-    if (!client) {
-      throw new Error('LanceDB client not initialized. Call LanceStorage.create() first.');
-    }
-    if (!tableName) {
-      throw new Error('tableName is required for getTableSchema.');
-    }
-  } catch (validationError: any) {
-    throw new MastraError(
-      {
-        id: 'STORAGE_LANCE_STORAGE_GET_TABLE_SCHEMA_INVALID_ARGS',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.USER,
-        text: validationError.message,
-        details: { tableName },
-      },
-      validationError,
-    );
-  }
-
-  try {
-    const table = await client.openTable(tableName);
-    const rawSchema = await table.schema();
-    const fields = rawSchema.fields as FieldLike[];
-
-    // Convert schema to SchemaLike format
-    return {
-      fields,
-      metadata: new Map<string, string>(),
-      get names() {
-        return fields.map((field: FieldLike) => field.name);
-      },
-    };
-  } catch (error: any) {
-    throw new MastraError(
-      {
-        id: 'STORAGE_LANCE_STORAGE_GET_TABLE_SCHEMA_FAILED',
-        domain: ErrorDomain.STORAGE,
-        category: ErrorCategory.THIRD_PARTY,
-        details: { tableName },
-      },
-      error,
-    );
-  }
-}