@mastra/core 0.10.13 → 0.10.14

package/dist/storage/index.cjs

@@ -0,0 +1,336 @@
+'use strict';
+
+var chunkF2WMR75C_cjs = require('../chunk-F2WMR75C.cjs');
+var chunkQUSEDVYI_cjs = require('../chunk-QUSEDVYI.cjs');
+var chunkQQ5K5TZE_cjs = require('../chunk-QQ5K5TZE.cjs');
+
+// src/storage/mock.ts
+var MockStore = class extends chunkF2WMR75C_cjs.MastraStorage {
+  data = {
+    mastra_workflow_snapshot: {},
+    mastra_evals: {},
+    mastra_messages: {},
+    mastra_threads: {},
+    mastra_traces: {},
+    mastra_resources: {}
+  };
+  constructor() {
+    super({ name: "MockStore" });
+    this.hasInitialized = Promise.resolve(true);
+  }
+  async createTable(_) {
+  }
+  async alterTable({
+    tableName
+  }) {
+    this.logger.debug(`MockStore: alterTable called for ${tableName}`);
+  }
+  async clearTable({ tableName }) {
+    this.logger.debug(`MockStore: clearTable called for ${tableName}`);
+    this.data[tableName] = {};
+  }
+  async insert({ tableName, record }) {
+    this.logger.debug(`MockStore: insert called for ${tableName}`, record);
+    this.data[tableName][record.run_id] = JSON.parse(JSON.stringify(record));
+  }
+  async batchInsert({ tableName, records }) {
+    this.logger.debug(`MockStore: batchInsert called for ${tableName} with ${records.length} records`);
+    for (const record of records) {
+      this.data[tableName][record.run_id] = JSON.parse(JSON.stringify(record));
+    }
+  }
+  async load({ tableName, keys }) {
+    this.logger.debug(`MockStore: load called for ${tableName} with keys`, keys);
+    const record = this.data[tableName][keys.run_id];
+    return record ? record : null;
+  }
+  async getThreadById({ threadId }) {
+    this.logger.debug(`MockStore: getThreadById called for ${threadId}`);
+    const thread = Object.values(this.data.mastra_threads).find((t) => t.id === threadId);
+    return thread ? thread : null;
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    this.logger.debug(`MockStore: getThreadsByResourceId called for ${resourceId}`);
+    const threads = Object.values(this.data.mastra_threads).filter((t) => t.resourceId === resourceId);
+    return threads;
+  }
+  async saveThread({ thread }) {
+    this.logger.debug(`MockStore: saveThread called for ${thread.id}`);
+    const key = thread.id;
+    this.data.mastra_threads[key] = thread;
+    return thread;
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    this.logger.debug(`MockStore: updateThread called for ${id}`);
+    const thread = this.data.mastra_threads[id];
+    if (thread) {
+      thread.title = title;
+      thread.metadata = { ...thread.metadata, ...metadata };
+      thread.updatedAt = /* @__PURE__ */ new Date();
+    }
+    return thread;
+  }
+  async deleteThread({ threadId }) {
+    this.logger.debug(`MockStore: deleteThread called for ${threadId}`);
+    delete this.data.mastra_threads[threadId];
+    this.data.mastra_messages = Object.fromEntries(
+      Object.entries(this.data.mastra_messages).filter(([, msg]) => msg.threadId !== threadId)
+    );
+  }
+  async getResourceById({ resourceId }) {
+    this.logger.debug(`MockStore: getResourceById called for ${resourceId}`);
+    const resource = this.data.mastra_resources[resourceId];
+    return resource ? resource : null;
+  }
+  async saveResource({ resource }) {
+    this.logger.debug(`MockStore: saveResource called for ${resource.id}`);
+    this.data.mastra_resources[resource.id] = JSON.parse(JSON.stringify(resource));
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    this.logger.debug(`MockStore: updateResource called for ${resourceId}`);
+    let resource = this.data.mastra_resources[resourceId];
+    if (!resource) {
+      resource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    } else {
+      resource = {
+        ...resource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : resource.workingMemory,
+        metadata: {
+          ...resource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    this.data.mastra_resources[resourceId] = resource;
+    return resource;
+  }
+  async getMessages({ threadId, selectBy }) {
+    this.logger.debug(`MockStore: getMessages called for thread ${threadId}`);
+    let messages = Object.values(this.data.mastra_messages).filter((msg) => msg.threadId === threadId);
+    if (selectBy?.last) {
+      messages = messages.slice(-selectBy.last);
+    }
+    messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return messages;
+  }
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
+    this.logger.debug(`MockStore: saveMessages called with ${messages.length} messages`);
+    for (const message of messages) {
+      const key = message.id;
+      this.data.mastra_messages[key] = message;
+    }
+    const list = new chunkQUSEDVYI_cjs.MessageList().add(messages, "memory");
+    if (format === `v2`) return list.get.all.v2();
+    return list.get.all.v1();
+  }
+  async updateMessages(args) {
+    this.logger.debug(`MockStore: updateMessages called with ${args.messages.length} messages`);
+    const messages = args.messages.map((m) => this.data.mastra_messages[m.id]);
+    return messages;
+  }
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes,
+    filters,
+    fromDate,
+    toDate
+  }) {
+    this.logger.debug(`MockStore: getTraces called`);
+    let traces = Object.values(this.data.mastra_traces);
+    if (name) traces = traces.filter((t) => t.name?.startsWith(name));
+    if (scope) traces = traces.filter((t) => t.scope === scope);
+    if (attributes) {
+      traces = traces.filter(
+        (t) => Object.entries(attributes).every(([key, value]) => t.attributes?.[key] === value)
+      );
+    }
+    if (filters) {
+      traces = traces.filter((t) => Object.entries(filters).every(([key, value]) => t[key] === value));
+    }
+    if (fromDate) traces = traces.filter((t) => new Date(t.createdAt) >= fromDate);
+    if (toDate) traces = traces.filter((t) => new Date(t.createdAt) <= toDate);
+    traces.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return traces.slice(start, end);
+  }
+  async getEvalsByAgentName(agentName, type) {
+    this.logger.debug(`MockStore: getEvalsByAgentName called for ${agentName}`);
+    let evals = Object.values(this.data.mastra_evals).filter((e) => e.agentName === agentName);
+    if (type === "test") {
+      evals = evals.filter((e) => e.testInfo && e.testInfo.testPath);
+    } else if (type === "live") {
+      evals = evals.filter((e) => !e.testInfo || !e.testInfo.testPath);
+    }
+    evals.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    return evals;
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    this.logger.debug(`MockStore: getWorkflowRuns called`);
+    let runs = Object.values(this.data.mastra_workflow_snapshot || {});
+    if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
+    if (fromDate) runs = runs.filter((run) => new Date(run.createdAt) >= fromDate);
+    if (toDate) runs = runs.filter((run) => new Date(run.createdAt) <= toDate);
+    if (resourceId) runs = runs.filter((run) => run.resourceId === resourceId);
+    const total = runs.length;
+    runs.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    if (limit !== void 0 && offset !== void 0) {
+      const start = offset;
+      const end = start + limit;
+      runs = runs.slice(start, end);
+    }
+    const parsedRuns = runs.map((run) => ({
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : { ...run.snapshot },
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name
+    }));
+    return { runs: parsedRuns, total };
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    this.logger.debug(`MockStore: getWorkflowRunById called for runId ${runId}`);
+    let run = Object.values(this.data.mastra_workflow_snapshot || {}).find((r) => r.run_id === runId);
+    if (run && workflowName && run.workflow_name !== workflowName) {
+      run = void 0;
+    }
+    if (!run) return null;
+    const parsedRun = {
+      ...run,
+      snapshot: typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot,
+      createdAt: new Date(run.createdAt),
+      updatedAt: new Date(run.updatedAt),
+      runId: run.run_id,
+      workflowName: run.workflow_name
+    };
+    return parsedRun;
+  }
+  async getTracesPaginated({
+    name,
+    scope,
+    attributes,
+    page,
+    perPage,
+    fromDate,
+    toDate
+  }) {
+    this.logger.debug(`MockStore: getTracesPaginated called`);
+    let traces = Object.values(this.data.mastra_traces);
+    if (name) traces = traces.filter((t) => t.name?.startsWith(name));
+    if (scope) traces = traces.filter((t) => t.scope === scope);
+    if (attributes) {
+      traces = traces.filter(
+        (t) => Object.entries(attributes).every(([key, value]) => t.attributes?.[key] === value)
+      );
+    }
+    if (fromDate) traces = traces.filter((t) => new Date(t.createdAt) >= fromDate);
+    if (toDate) traces = traces.filter((t) => new Date(t.createdAt) <= toDate);
+    traces.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return {
+      traces: traces.slice(start, end),
+      total: traces.length,
+      page,
+      perPage,
+      hasMore: traces.length > end
+    };
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    this.logger.debug(`MockStore: getThreadsByResourceIdPaginated called for ${args.resourceId}`);
+    const threads = Object.values(this.data.mastra_threads).filter((t) => t.resourceId === args.resourceId);
+    return {
+      threads: threads.slice(args.page * args.perPage, (args.page + 1) * args.perPage),
+      total: threads.length,
+      page: args.page,
+      perPage: args.perPage,
+      hasMore: threads.length > (args.page + 1) * args.perPage
+    };
+  }
+  async getMessagesPaginated({
+    threadId,
+    selectBy
+  }) {
+    this.logger.debug(`MockStore: getMessagesPaginated called for thread ${threadId}`);
+    const { page = 0, perPage = 40 } = selectBy?.pagination || {};
+    let messages = Object.values(this.data.mastra_messages).filter((msg) => msg.threadId === threadId);
+    if (selectBy?.last) {
+      messages = messages.slice(-selectBy.last);
+    }
+    messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    const start = page * perPage;
+    const end = start + perPage;
+    return {
+      messages: messages.slice(start, end),
+      total: messages.length,
+      page,
+      perPage,
+      hasMore: messages.length > end
+    };
+  }
+};
+
+Object.defineProperty(exports, "MastraStorage", {
+  enumerable: true,
+  get: function () { return chunkF2WMR75C_cjs.MastraStorage; }
+});
+Object.defineProperty(exports, "TABLE_EVALS", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_EVALS; }
+});
+Object.defineProperty(exports, "TABLE_MESSAGES", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_MESSAGES; }
+});
+Object.defineProperty(exports, "TABLE_RESOURCES", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_RESOURCES; }
+});
+Object.defineProperty(exports, "TABLE_SCHEMAS", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_SCHEMAS; }
+});
+Object.defineProperty(exports, "TABLE_THREADS", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_THREADS; }
+});
+Object.defineProperty(exports, "TABLE_TRACES", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_TRACES; }
+});
+Object.defineProperty(exports, "TABLE_WORKFLOW_SNAPSHOT", {
+  enumerable: true,
+  get: function () { return chunkQQ5K5TZE_cjs.TABLE_WORKFLOW_SNAPSHOT; }
+});
+exports.MockStore = MockStore;

package/dist/storage/index.d.cts

@@ -0,0 +1,149 @@
+import { o as MastraStorage, p as TABLE_NAMES, q as StorageColumn, r as StorageThreadType, s as StorageResourceType, t as MastraMessageV2, u as StorageGetMessagesArg, v as MastraMessageV1, E as EvalRow, w as WorkflowRuns, x as WorkflowRun, P as PaginationInfo } from '../base-CS5eSXbL.cjs';
+export { z as LegacyWorkflowRun, y as LegacyWorkflowRuns, B as PaginationArgs, D as StorageGetTracesArg, G as TABLE_EVALS, H as TABLE_MESSAGES, K as TABLE_RESOURCES, O as TABLE_SCHEMAS, I as TABLE_THREADS, J as TABLE_TRACES, F as TABLE_WORKFLOW_SNAPSHOT } from '../base-CS5eSXbL.cjs';
+import { T as Trace } from '../base-B_y9sMg0.cjs';
+import 'ai';
+import 'zod';
+import '../logger-B8XXh6ya.cjs';
+import '../error/index.cjs';
+import 'stream';
+import 'json-schema';
+import '../types-Bo1uigWx.cjs';
+import 'sift';
+import '../runtime-context/index.cjs';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
+import '../tts/index.cjs';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.cjs';
+import 'ai/test';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import 'hono/cors';
+import 'hono-openapi';
+import '@opentelemetry/sdk-trace-base';
+
+declare class MockStore extends MastraStorage {
+    private data;
+    constructor();
+    createTable(_: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    alterTable({ tableName, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getMessages<T extends MastraMessageV2[]>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    updateMessages(args: {
+        messages: Partial<MastraMessageV2> & {
+            id: string;
+        }[];
+    }): Promise<MastraMessageV2[]>;
+    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[]>;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    getTracesPaginated({ name, scope, attributes, page, perPage, fromDate, toDate, }: {
+        name?: string;
+        scope?: string;
+        attributes?: Record<string, string>;
+        page: number;
+        perPage: number;
+        fromDate?: Date;
+        toDate?: Date;
+    }): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated({ threadId, selectBy, }: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+}
+
+export { EvalRow, MastraStorage, MockStore, PaginationInfo, StorageColumn, StorageGetMessagesArg, StorageResourceType, TABLE_NAMES, WorkflowRun, WorkflowRuns };

package/dist/storage/index.d.ts

@@ -0,0 +1,149 @@
+import { o as MastraStorage, p as TABLE_NAMES, q as StorageColumn, r as StorageThreadType, s as StorageResourceType, t as MastraMessageV2, u as StorageGetMessagesArg, v as MastraMessageV1, E as EvalRow, w as WorkflowRuns, x as WorkflowRun, P as PaginationInfo } from '../base-DBhKcre4.js';
+export { z as LegacyWorkflowRun, y as LegacyWorkflowRuns, B as PaginationArgs, D as StorageGetTracesArg, G as TABLE_EVALS, H as TABLE_MESSAGES, K as TABLE_RESOURCES, O as TABLE_SCHEMAS, I as TABLE_THREADS, J as TABLE_TRACES, F as TABLE_WORKFLOW_SNAPSHOT } from '../base-DBhKcre4.js';
+import { T as Trace } from '../base-ClrXcCRx.js';
+import 'ai';
+import 'zod';
+import '../logger-Bpa2oLL4.js';
+import '../error/index.js';
+import 'stream';
+import 'json-schema';
+import '../types-Bo1uigWx.js';
+import 'sift';
+import '../runtime-context/index.js';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../vector/index.js';
+import '../vector/filter/index.js';
+import '../tts/index.js';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../workflows/constants.js';
+import 'ai/test';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import 'hono/cors';
+import 'hono-openapi';
+import '@opentelemetry/sdk-trace-base';
+
+declare class MockStore extends MastraStorage {
+    private data;
+    constructor();
+    createTable(_: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    alterTable({ tableName, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getMessages<T extends MastraMessageV2[]>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    updateMessages(args: {
+        messages: Partial<MastraMessageV2> & {
+            id: string;
+        }[];
+    }): Promise<MastraMessageV2[]>;
+    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[]>;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    getTracesPaginated({ name, scope, attributes, page, perPage, fromDate, toDate, }: {
+        name?: string;
+        scope?: string;
+        attributes?: Record<string, string>;
+        page: number;
+        perPage: number;
+        fromDate?: Date;
+        toDate?: Date;
+    }): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated({ threadId, selectBy, }: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+}
+
+export { EvalRow, MastraStorage, MockStore, PaginationInfo, StorageColumn, StorageGetMessagesArg, StorageResourceType, TABLE_NAMES, WorkflowRun, WorkflowRuns };