@mastra/core 1.0.0-beta.14 → 1.0.0-beta.16

package/dist/{chunk-GBQXIVL6.js → chunk-GNUITL2N.js}

@@ -1,186 +1,9 @@
-import { MessageList } from './chunk-4AT6YQKZ.js';
-import { MastraError } from './chunk-YPLZDWG7.js';
+import { MessageList } from './chunk-QXL3F3T2.js';
+import { TABLE_SCHEMAS, TABLE_SCORERS, listTracesArgsSchema, TABLE_WORKFLOW_SNAPSHOT } from './chunk-CSCTVLD5.js';
+import { MastraError } from './chunk-FJEVLHJT.js';
 import { MastraBase } from './chunk-LSHPJWM5.js';
 
-// src/storage/constants.ts
-var TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
-var TABLE_MESSAGES = "mastra_messages";
-var TABLE_THREADS = "mastra_threads";
-var TABLE_TRACES = "mastra_traces";
-var TABLE_RESOURCES = "mastra_resources";
-var TABLE_SCORERS = "mastra_scorers";
-var TABLE_SPANS = "mastra_ai_spans";
-var TABLE_AGENTS = "mastra_agents";
-var SCORERS_SCHEMA = {
-  id: { type: "text", nullable: false, primaryKey: true },
-  scorerId: { type: "text" },
-  traceId: { type: "text", nullable: true },
-  spanId: { type: "text", nullable: true },
-  runId: { type: "text" },
-  scorer: { type: "jsonb" },
-  preprocessStepResult: { type: "jsonb", nullable: true },
-  extractStepResult: { type: "jsonb", nullable: true },
-  analyzeStepResult: { type: "jsonb", nullable: true },
-  score: { type: "float" },
-  reason: { type: "text", nullable: true },
-  metadata: { type: "jsonb", nullable: true },
-  preprocessPrompt: { type: "text", nullable: true },
-  extractPrompt: { type: "text", nullable: true },
-  generateScorePrompt: { type: "text", nullable: true },
-  generateReasonPrompt: { type: "text", nullable: true },
-  analyzePrompt: { type: "text", nullable: true },
-  // Deprecated
-  reasonPrompt: { type: "text", nullable: true },
-  input: { type: "jsonb" },
-  output: { type: "jsonb" },
-  // MESSAGE OUTPUT
-  additionalContext: { type: "jsonb", nullable: true },
-  // DATA FROM THE CONTEXT PARAM ON AN AGENT
-  requestContext: { type: "jsonb", nullable: true },
-  // THE EVALUATE Request Context FOR THE RUN
-  /**
-   * Things you can evaluate
-   */
-  entityType: { type: "text", nullable: true },
-  // WORKFLOW, AGENT, TOOL, STEP, NETWORK
-  entity: { type: "jsonb", nullable: true },
-  // MINIMAL JSON DATA ABOUT WORKFLOW, AGENT, TOOL, STEP, NETWORK
-  entityId: { type: "text", nullable: true },
-  source: { type: "text" },
-  resourceId: { type: "text", nullable: true },
-  threadId: { type: "text", nullable: true },
-  createdAt: { type: "timestamp" },
-  updatedAt: { type: "timestamp" }
-};
-var SPAN_SCHEMA = {
-  // Composite primary key of traceId and spanId
-  traceId: { type: "text", nullable: false },
-  spanId: { type: "text", nullable: false },
-  parentSpanId: { type: "text", nullable: true },
-  name: { type: "text", nullable: false },
-  scope: { type: "jsonb", nullable: true },
-  // Mastra package info {"core-version": "0.1.0"}
-  spanType: { type: "text", nullable: false },
-  // WORKFLOW_RUN, WORKFLOW_STEP, AGENT_RUN, AGENT_STEP, TOOL_RUN, TOOL_STEP, etc.
-  attributes: { type: "jsonb", nullable: true },
-  metadata: { type: "jsonb", nullable: true },
-  links: { type: "jsonb", nullable: true },
-  input: { type: "jsonb", nullable: true },
-  output: { type: "jsonb", nullable: true },
-  error: { type: "jsonb", nullable: true },
-  startedAt: { type: "timestamp", nullable: false },
-  // When the span started
-  endedAt: { type: "timestamp", nullable: true },
-  // When the span ended
-  createdAt: { type: "timestamp", nullable: false },
-  // The time the database record was created
-  updatedAt: { type: "timestamp", nullable: true },
-  // The time the database record was last updated
-  isEvent: { type: "boolean", nullable: false }
-};
-var AGENTS_SCHEMA = {
-  id: { type: "text", nullable: false, primaryKey: true },
-  name: { type: "text", nullable: false },
-  description: { type: "text", nullable: true },
-  instructions: { type: "text", nullable: false },
-  // System instructions for the agent
-  model: { type: "jsonb", nullable: false },
-  // Model configuration (provider, name, etc.)
-  tools: { type: "jsonb", nullable: true },
-  // Serialized tool references/configurations
-  defaultOptions: { type: "jsonb", nullable: true },
-  // Default options for generate/stream calls
-  workflows: { type: "jsonb", nullable: true },
-  // Workflow references (IDs or configurations)
-  agents: { type: "jsonb", nullable: true },
-  // Sub-agent references (IDs or configurations)
-  inputProcessors: { type: "jsonb", nullable: true },
-  // Input processor configurations
-  outputProcessors: { type: "jsonb", nullable: true },
-  // Output processor configurations
-  memory: { type: "jsonb", nullable: true },
-  // Memory configuration
-  scorers: { type: "jsonb", nullable: true },
-  // Scorer configurations
-  metadata: { type: "jsonb", nullable: true },
-  // Additional metadata for the agent
-  createdAt: { type: "timestamp", nullable: false },
-  updatedAt: { type: "timestamp", nullable: false }
-};
-var TABLE_SCHEMAS = {
-  [TABLE_WORKFLOW_SNAPSHOT]: {
-    workflow_name: {
-      type: "text"
-    },
-    run_id: {
-      type: "text"
-    },
-    resourceId: { type: "text", nullable: true },
-    snapshot: {
-      type: "text"
-    },
-    createdAt: {
-      type: "timestamp"
-    },
-    updatedAt: {
-      type: "timestamp"
-    }
-  },
-  [TABLE_SCORERS]: SCORERS_SCHEMA,
-  [TABLE_THREADS]: {
-    id: { type: "text", nullable: false, primaryKey: true },
-    resourceId: { type: "text", nullable: false },
-    title: { type: "text", nullable: false },
-    metadata: { type: "text", nullable: true },
-    createdAt: { type: "timestamp", nullable: false },
-    updatedAt: { type: "timestamp", nullable: false }
-  },
-  [TABLE_MESSAGES]: {
-    id: { type: "text", nullable: false, primaryKey: true },
-    thread_id: { type: "text", nullable: false },
-    content: { type: "text", nullable: false },
-    role: { type: "text", nullable: false },
-    type: { type: "text", nullable: false },
-    createdAt: { type: "timestamp", nullable: false },
-    resourceId: { type: "text", nullable: true }
-  },
-  [TABLE_SPANS]: SPAN_SCHEMA,
-  [TABLE_TRACES]: {
-    id: { type: "text", nullable: false, primaryKey: true },
-    parentSpanId: { type: "text", nullable: true },
-    name: { type: "text", nullable: false },
-    traceId: { type: "text", nullable: false },
-    scope: { type: "text", nullable: false },
-    kind: { type: "integer", nullable: false },
-    attributes: { type: "jsonb", nullable: true },
-    status: { type: "jsonb", nullable: true },
-    events: { type: "jsonb", nullable: true },
-    links: { type: "jsonb", nullable: true },
-    other: { type: "text", nullable: true },
-    startTime: { type: "bigint", nullable: false },
-    endTime: { type: "bigint", nullable: false },
-    createdAt: { type: "timestamp", nullable: false }
-  },
-  [TABLE_RESOURCES]: {
-    id: { type: "text", nullable: false, primaryKey: true },
-    workingMemory: { type: "text", nullable: true },
-    metadata: { type: "jsonb", nullable: true },
-    createdAt: { type: "timestamp", nullable: false },
-    updatedAt: { type: "timestamp", nullable: false }
-  },
-  [TABLE_AGENTS]: AGENTS_SCHEMA
-};
-
 // src/storage/base.ts
-function ensureDate(date) {
-  if (!date) return void 0;
-  return date instanceof Date ? date : new Date(date);
-}
-function serializeDate(date) {
-  if (!date) return void 0;
-  const dateObj = ensureDate(date);
-  return dateObj?.toISOString();
-}
 function normalizePerPage(perPageInput, defaultValue) {
   if (perPageInput === false) {
     return Number.MAX_SAFE_INTEGER;
@@ -204,558 +27,149 @@ var MastraStorage = class extends MastraBase {
   stores;
   /**
    * When true, automatic initialization (table creation/migrations) is disabled.
-   * This is useful for CI/CD pipelines where you want to:
-   * 1. Run migrations explicitly during deployment (not at runtime)
-   * 2. Use different credentials for schema changes vs runtime operations
-   *
-   * When disableInit is true:
-   * - The storage will not automatically create/alter tables on first use
-   * - You must call `storage.init()` explicitly in your CI/CD scripts
-   *
-   * @example
-   * // In CI/CD script:
-   * const storage = new PostgresStore({ ...config, disableInit: false });
-   * await storage.init(); // Explicitly run migrations
-   *
-   * // In runtime application:
-   * const storage = new PostgresStore({ ...config, disableInit: true });
-   * // No auto-init, tables must already exist
    */
   disableInit = false;
-  constructor({ id, name, disableInit }) {
-    if (!id || typeof id !== "string" || id.trim() === "") {
+  constructor(config) {
+    const name = config.name ?? "MastraStorage";
+    if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
       throw new Error(`${name}: id must be provided and cannot be empty.`);
     }
     super({
       component: "STORAGE",
       name
     });
-    this.id = id;
-    this.disableInit = disableInit ?? false;
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: false,
-      resourceWorkingMemory: false,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: false,
-      observabilityInstance: false,
-      indexManagement: false,
-      listScoresBySpan: false,
-      agents: false
-    };
-  }
-  ensureDate(date) {
-    return ensureDate(date);
-  }
-  serializeDate(date) {
-    return serializeDate(date);
-  }
-  async getResourceById(_) {
-    throw new Error(
-      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
-    );
-  }
-  async saveResource(_) {
-    throw new Error(
-      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
-    );
-  }
-  async updateResource(_) {
-    throw new Error(
-      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
-    );
-  }
-  async listMessages(args) {
-    if (this.stores?.memory) {
-      return this.stores.memory.listMessages(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_MESSAGES_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Listing messages is not implemented by this storage adapter (${this.constructor.name})`
-    });
-  }
-  async listWorkflowRuns(args) {
-    if (this.stores?.workflows) {
-      return this.stores.workflows.listWorkflowRuns(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_WORKFLOW_RUNS_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Listing workflow runs is not implemented by this storage adapter (${this.constructor.name})`
-    });
-  }
-  async listThreadsByResourceId(args) {
-    if (this.stores?.memory) {
-      return this.stores.memory.listThreadsByResourceId(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_THREADS_BY_RESOURCE_ID_PAGINATED_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Listing threads by resource ID paginated is not implemented by this storage adapter (${this.constructor.name})`
-    });
-  }
-  async listMessagesById({ messageIds }) {
-    if (this.stores?.memory) {
-      const result = await this.stores.memory.listMessagesById({ messageIds });
-      return result;
+    this.id = config.id;
+    this.disableInit = config.disableInit ?? false;
+    if (config.default || config.domains) {
+      const defaultStores = config.default?.stores;
+      const domainOverrides = config.domains ?? {};
+      const hasDefaultDomains = defaultStores && Object.values(defaultStores).some((v) => v !== void 0);
+      const hasOverrideDomains = Object.values(domainOverrides).some((v) => v !== void 0);
+      if (!hasDefaultDomains && !hasOverrideDomains) {
+        throw new Error(
+          "MastraStorage requires at least one storage source. Provide either a default storage with domains or domain overrides."
+        );
+      }
+      this.stores = {
+        memory: domainOverrides.memory ?? defaultStores?.memory,
+        workflows: domainOverrides.workflows ?? defaultStores?.workflows,
+        scores: domainOverrides.scores ?? defaultStores?.scores,
+        observability: domainOverrides.observability ?? defaultStores?.observability,
+        agents: domainOverrides.agents ?? defaultStores?.agents
+      };
     }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_MESSAGES_BY_ID_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Listing messages by ID is not implemented by this storage adapter (${this.constructor.name})`
-    });
   }
-  async deleteMessages(_messageIds) {
-    throw new Error(
-      `Message deletion is not supported by this storage adapter (${this.constructor.name}). The deleteMessages method needs to be implemented in the storage adapter.`
-    );
+  /**
+   * Get a domain-specific storage interface.
+   *
+   * @param storeName - The name of the domain to access ('memory', 'workflows', 'scores', 'observability', 'agents')
+   * @returns The domain storage interface, or undefined if not available
+   *
+   * @example
+   * ```typescript
+   * const memory = await storage.getStore('memory');
+   * if (memory) {
+   *   await memory.saveThread({ thread });
+   * }
+   * ```
+   */
+  async getStore(storeName) {
+    return this.stores?.[storeName];
   }
+  /**
+   * Initialize all domain stores.
+   * This creates necessary tables, indexes, and performs any required migrations.
+   */
   async init() {
     if (this.shouldCacheInit && await this.hasInitialized) {
       return;
     }
-    const tableCreationTasks = [
-      this.createTable({
-        tableName: TABLE_WORKFLOW_SNAPSHOT,
-        schema: TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT]
-      }),
-      this.createTable({
-        tableName: TABLE_THREADS,
-        schema: TABLE_SCHEMAS[TABLE_THREADS]
-      }),
-      this.createTable({
-        tableName: TABLE_MESSAGES,
-        schema: TABLE_SCHEMAS[TABLE_MESSAGES]
-      }),
-      this.createTable({
-        tableName: TABLE_TRACES,
-        schema: TABLE_SCHEMAS[TABLE_TRACES]
-      }),
-      this.createTable({
-        tableName: TABLE_SCORERS,
-        schema: TABLE_SCHEMAS[TABLE_SCORERS]
-      })
-    ];
-    if (this.supports.resourceWorkingMemory) {
-      tableCreationTasks.push(
-        this.createTable({
-          tableName: TABLE_RESOURCES,
-          schema: TABLE_SCHEMAS[TABLE_RESOURCES]
-        })
-      );
-    }
-    if (this.supports.observabilityInstance) {
-      tableCreationTasks.push(
-        this.createTable({
-          tableName: TABLE_SPANS,
-          schema: TABLE_SCHEMAS[TABLE_SPANS]
-        })
-      );
+    const initTasks = [];
+    if (this.stores?.memory) {
+      initTasks.push(this.stores.memory.init());
     }
-    if (this.supports.agents) {
-      tableCreationTasks.push(
-        this.createTable({
-          tableName: TABLE_AGENTS,
-          schema: TABLE_SCHEMAS[TABLE_AGENTS]
-        })
-      );
+    if (this.stores?.workflows) {
+      initTasks.push(this.stores.workflows.init());
     }
-    this.hasInitialized = Promise.all(tableCreationTasks).then(() => true);
-    await this.hasInitialized;
-    await this?.alterTable?.({
-      tableName: TABLE_MESSAGES,
-      schema: TABLE_SCHEMAS[TABLE_MESSAGES],
-      ifNotExists: ["resourceId"]
-    });
-    await this?.alterTable?.({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      schema: TABLE_SCHEMAS[TABLE_WORKFLOW_SNAPSHOT],
-      ifNotExists: ["resourceId"]
-    });
-    await this?.alterTable?.({
-      tableName: TABLE_SCORERS,
-      schema: TABLE_SCHEMAS[TABLE_SCORERS],
-      ifNotExists: ["spanId", "requestContext"]
-    });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    await this.init();
-    const data = {
-      workflow_name: workflowName,
-      run_id: runId,
-      resourceId,
-      snapshot,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
-    await this.insert({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      record: data
-    });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    if (!this.hasInitialized) {
-      await this.init();
+    if (this.stores?.scores) {
+      initTasks.push(this.stores.scores.init());
     }
-    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const d = await this.load({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      keys: { workflow_name: workflowName, run_id: runId }
-    });
-    return d ? d.snapshot : null;
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination: _pagination
-  }) {
-    throw new MastraError({
-      id: "SCORES_STORAGE_GET_SCORES_BY_SPAN_NOT_IMPLEMENTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      details: { traceId, spanId }
-    });
-  }
-  /**
-   * OBSERVABILITY
-   */
-  /**
-   * Provides hints for tracing strategy selection by the DefaultExporter.
-   * Storage adapters can override this to specify their preferred and supported strategies.
-   */
-  get tracingStrategy() {
     if (this.stores?.observability) {
-      return this.stores.observability.tracingStrategy;
+      initTasks.push(this.stores.observability.init());
     }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_TRACING_STRATEGY_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Creates a single Span record in the storage provider.
-   */
-  async createSpan(span) {
-    if (this.stores?.observability) {
-      return this.stores.observability.createSpan(span);
+    if (this.stores?.agents) {
+      initTasks.push(this.stores.agents.init());
     }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_CREATE_AI_SPAN_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+    this.hasInitialized = Promise.all(initTasks).then(() => true);
+    await this.hasInitialized;
   }
+};
+
+// src/storage/domains/base.ts
+var StorageDomain = class extends MastraBase {
   /**
-   * Updates a single Span with partial data. Primarily used for realtime trace creation.
+   * Initialize the storage domain.
+   * This should create any necessary tables/collections.
+   * Default implementation is a no-op - override in adapters that need initialization.
    */
-  async updateSpan(params) {
-    if (this.stores?.observability) {
-      return this.stores.observability.updateSpan(params);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_UPDATE_AI_SPAN_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+  async init() {
   }
-  /**
-   * Retrieves a single trace with all its associated spans.
-   */
-  async getTrace(traceId) {
-    if (this.stores?.observability) {
-      return this.stores.observability.getTrace(traceId);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_GET_TRACE_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
+};
+
+// src/storage/domains/agents/base.ts
+var AgentsStorage = class extends StorageDomain {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "AGENTS"
     });
   }
   /**
-   * Retrieves a paginated list of traces with optional filtering.
+   * Parses orderBy input for consistent sorting behavior.
    */
-  async getTracesPaginated(args) {
-    if (this.stores?.observability) {
-      return this.stores.observability.getTracesPaginated(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_GET_TRACES_PAGINATED_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+  parseOrderBy(orderBy, defaultDirection = "DESC") {
+    return {
+      field: orderBy?.field && orderBy.field in AGENT_ORDER_BY_SET ? orderBy.field : "createdAt",
+      direction: orderBy?.direction && orderBy.direction in AGENT_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
+    };
   }
-  /**
-   * Creates multiple Spans in a single batch.
-   */
-  async batchCreateSpans(args) {
-    if (this.stores?.observability) {
-      return this.stores.observability.batchCreateSpans(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_BATCH_CREATE_AI_SPANS_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+};
+var AGENT_ORDER_BY_SET = {
+  createdAt: true,
+  updatedAt: true
+};
+var AGENT_SORT_DIRECTION_SET = {
+  ASC: true,
+  DESC: true
+};
+
+// src/storage/domains/agents/inmemory.ts
+var InMemoryAgentsStorage = class extends AgentsStorage {
+  db;
+  constructor({ db }) {
+    super();
+    this.db = db;
   }
-  /**
-   * Updates multiple Spans in a single batch.
-   */
-  async batchUpdateSpans(args) {
-    if (this.stores?.observability) {
-      return this.stores.observability.batchUpdateSpans(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_BATCH_UPDATE_AI_SPANS_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+  async dangerouslyClearAll() {
+    this.db.agents.clear();
   }
-  /**
-   * Deletes multiple traces and all their associated spans in a single batch operation.
-   */
-  async batchDeleteTraces(args) {
-    if (this.stores?.observability) {
-      return this.stores.observability.batchDeleteTraces(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_BATCH_DELETE_TRACES_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `tracing is not supported by this storage adapter (${this.constructor.name})`
-    });
+  async getAgentById({ id }) {
+    this.logger.debug(`InMemoryAgentsStorage: getAgentById called for ${id}`);
+    const agent = this.db.agents.get(id);
+    return agent ? {
+      ...agent,
+      metadata: agent.metadata ? { ...agent.metadata } : agent.metadata,
+      model: { ...agent.model },
+      tools: agent.tools ? [...agent.tools] : agent.tools,
+      workflows: agent.workflows ? [...agent.workflows] : agent.workflows,
+      agents: agent.agents ? [...agent.agents] : agent.agents,
+      scorers: agent.scorers ? { ...agent.scorers } : agent.scorers
+    } : null;
   }
-  /**
-   * DATABASE INDEX MANAGEMENT
-   * These methods delegate to the operations store for index management.
-   * Storage adapters that support indexes should implement these in their operations class.
-   */
-  /**
-   * Creates a database index on specified columns
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async createIndex(options) {
-    if (this.stores?.operations) {
-      return this.stores.operations.createIndex(options);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_CREATE_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Drops a database index by name
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async dropIndex(indexName) {
-    if (this.stores?.operations) {
-      return this.stores.operations.dropIndex(indexName);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_DROP_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Lists database indexes for a table or all tables
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async listIndexes(tableName) {
-    if (this.stores?.operations) {
-      return this.stores.operations.listIndexes(tableName);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_INDEXES_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Gets detailed statistics for a specific index
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async describeIndex(indexName) {
-    if (this.stores?.operations) {
-      return this.stores.operations.describeIndex(indexName);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_DESCRIBE_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * AGENTS STORAGE
-   * These methods delegate to the agents store for agent CRUD operations.
-   * This enables dynamic creation of agents via Mastra Studio.
-   */
-  /**
-   * Retrieves an agent by its unique identifier.
-   * @param id - The unique identifier of the agent
-   * @returns The agent if found, null otherwise
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async getAgentById({ id }) {
-    if (this.stores?.agents) {
-      return this.stores.agents.getAgentById({ id });
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_GET_AGENT_BY_ID_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Creates a new agent in storage.
-   * @param agent - The agent data to create
-   * @returns The created agent with timestamps
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async createAgent({ agent }) {
-    if (this.stores?.agents) {
-      return this.stores.agents.createAgent({ agent });
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_CREATE_AGENT_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Updates an existing agent in storage.
-   * @param id - The unique identifier of the agent to update
-   * @param updates - The fields to update
-   * @returns The updated agent
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async updateAgent(args) {
-    if (this.stores?.agents) {
-      return this.stores.agents.updateAgent(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_UPDATE_AGENT_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Deletes an agent from storage.
-   * @param id - The unique identifier of the agent to delete
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async deleteAgent({ id }) {
-    if (this.stores?.agents) {
-      return this.stores.agents.deleteAgent({ id });
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_DELETE_AGENT_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-  /**
-   * Lists all agents with optional pagination.
-   * @param args - Pagination and ordering options
-   * @returns Paginated list of agents
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async listAgents(args) {
-    if (this.stores?.agents) {
-      return this.stores.agents.listAgents(args);
-    }
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_AGENTS_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
-    });
-  }
-};
-
-// src/storage/domains/agents/base.ts
-var AgentsStorage = class extends MastraBase {
-  constructor() {
-    super({
-      component: "STORAGE",
-      name: "AGENTS"
-    });
-  }
-  /**
-   * Parses orderBy input for consistent sorting behavior.
-   */
-  parseOrderBy(orderBy, defaultDirection = "DESC") {
-    return {
-      field: orderBy?.field && orderBy.field in AGENT_ORDER_BY_SET ? orderBy.field : "createdAt",
-      direction: orderBy?.direction && orderBy.direction in AGENT_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
-    };
-  }
-};
-var AGENT_ORDER_BY_SET = {
-  createdAt: true,
-  updatedAt: true
-};
-var AGENT_SORT_DIRECTION_SET = {
-  ASC: true,
-  DESC: true
-};
-
-// src/storage/domains/agents/inmemory.ts
-var InMemoryAgentsStorage = class extends AgentsStorage {
-  collection;
-  constructor({ collection }) {
-    super();
-    this.collection = collection;
-  }
-  async getAgentById({ id }) {
-    this.logger.debug(`InMemoryAgentsStorage: getAgentById called for ${id}`);
-    const agent = this.collection.get(id);
-    return agent ? {
-      ...agent,
-      metadata: agent.metadata ? { ...agent.metadata } : agent.metadata,
-      model: { ...agent.model },
-      tools: agent.tools ? [...agent.tools] : agent.tools,
-      workflows: agent.workflows ? [...agent.workflows] : agent.workflows,
-      agents: agent.agents ? [...agent.agents] : agent.agents,
-      scorers: agent.scorers ? { ...agent.scorers } : agent.scorers
-    } : null;
-  }
-  async createAgent({ agent }) {
-    this.logger.debug(`InMemoryAgentsStorage: createAgent called for ${agent.id}`);
-    if (this.collection.has(agent.id)) {
-      throw new Error(`Agent with id ${agent.id} already exists`);
+  async createAgent({ agent }) {
+    this.logger.debug(`InMemoryAgentsStorage: createAgent called for ${agent.id}`);
+    if (this.db.agents.has(agent.id)) {
+      throw new Error(`Agent with id ${agent.id} already exists`);
     }
     const now = /* @__PURE__ */ new Date();
     const newAgent = {
@@ -763,12 +177,12 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       createdAt: now,
       updatedAt: now
     };
-    this.collection.set(agent.id, newAgent);
+    this.db.agents.set(agent.id, newAgent);
     return { ...newAgent };
   }
   async updateAgent({ id, ...updates }) {
     this.logger.debug(`InMemoryAgentsStorage: updateAgent called for ${id}`);
-    const existingAgent = this.collection.get(id);
+    const existingAgent = this.db.agents.get(id);
     if (!existingAgent) {
       throw new Error(`Agent with id ${id} not found`);
     }
@@ -793,12 +207,12 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    this.collection.set(id, updatedAgent);
+    this.db.agents.set(id, updatedAgent);
     return { ...updatedAgent };
   }
   async deleteAgent({ id }) {
     this.logger.debug(`InMemoryAgentsStorage: deleteAgent called for ${id}`);
-    this.collection.delete(id);
+    this.db.agents.delete(id);
   }
   async listAgents(args) {
     const { page = 0, perPage: perPageInput, orderBy } = args || {};
@@ -812,7 +226,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     if (page * perPage > maxOffset) {
       throw new Error("page value too large");
     }
-    const agents = Array.from(this.collection.values());
+    const agents = Array.from(this.db.agents.values());
     const sortedAgents = this.sortAgents(agents, field, direction);
     const clonedAgents = sortedAgents.map((agent) => ({
       ...agent,
@@ -841,6 +255,30 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
   }
 };
 
+// src/storage/domains/inmemory-db.ts
+var InMemoryDB = class {
+  threads = /* @__PURE__ */ new Map();
+  messages = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  workflows = /* @__PURE__ */ new Map();
+  scores = /* @__PURE__ */ new Map();
+  traces = /* @__PURE__ */ new Map();
+  agents = /* @__PURE__ */ new Map();
+  /**
+   * Clears all data from all collections.
+   * Useful for testing.
+   */
+  clear() {
+    this.threads.clear();
+    this.messages.clear();
+    this.resources.clear();
+    this.workflows.clear();
+    this.scores.clear();
+    this.traces.clear();
+    this.agents.clear();
+  }
+};
+
 // src/storage/utils.ts
 function safelyParseJSON(input) {
   if (input && typeof input === "object") return input;
@@ -905,9 +343,57 @@ function createStorageErrorId(store, operation, status) {
 function createVectorErrorId(store, operation, status) {
   return createStoreErrorId("vector", store, operation, status);
 }
+function getSqlType(type) {
+  switch (type) {
+    case "text":
+      return "TEXT";
+    case "timestamp":
+      return "TIMESTAMP";
+    case "float":
+      return "FLOAT";
+    case "integer":
+      return "INTEGER";
+    case "bigint":
+      return "BIGINT";
+    case "jsonb":
+      return "JSONB";
+    case "boolean":
+      return "BOOLEAN";
+    default:
+      return "TEXT";
+  }
+}
+function getDefaultValue(type) {
+  switch (type) {
+    case "text":
+    case "uuid":
+      return "DEFAULT ''";
+    case "timestamp":
+      return "DEFAULT '1970-01-01 00:00:00'";
+    case "integer":
+    case "bigint":
+    case "float":
+      return "DEFAULT 0";
+    case "jsonb":
+      return "DEFAULT '{}'";
+    case "boolean":
+      return "DEFAULT FALSE";
+    default:
+      return "DEFAULT ''";
+  }
+}
+function ensureDate(date) {
+  if (!date) return void 0;
+  return date instanceof Date ? date : new Date(date);
+}
+function serializeDate(date) {
+  if (!date) return void 0;
+  const dateObj = ensureDate(date);
+  return dateObj?.toISOString();
+}
 
 // src/storage/domains/memory/base.ts
-var MemoryStorage = class extends MastraBase {
+var MemoryStorage = class extends StorageDomain {
   constructor() {
     super({
       component: "STORAGE",
@@ -952,25 +438,25 @@ var THREAD_THREAD_SORT_DIRECTION_SET = {
 
 // src/storage/domains/memory/inmemory.ts
 var InMemoryMemory = class extends MemoryStorage {
-  collection;
-  operations;
-  constructor({
-    collection,
-    operations
-  }) {
+  db;
+  constructor({ db }) {
     super();
-    this.collection = collection;
-    this.operations = operations;
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.threads.clear();
+    this.db.messages.clear();
+    this.db.resources.clear();
   }
   async getThreadById({ threadId }) {
-    this.logger.debug(`MockStore: getThreadById called for ${threadId}`);
-    const thread = this.collection.threads.get(threadId);
+    this.logger.debug(`InMemoryMemory: getThreadById called for ${threadId}`);
+    const thread = this.db.threads.get(threadId);
     return thread ? { ...thread, metadata: thread.metadata ? { ...thread.metadata } : thread.metadata } : null;
   }
   async saveThread({ thread }) {
-    this.logger.debug(`MockStore: saveThread called for ${thread.id}`);
+    this.logger.debug(`InMemoryMemory: saveThread called for ${thread.id}`);
     const key = thread.id;
-    this.collection.threads.set(key, thread);
+    this.db.threads.set(key, thread);
     return thread;
   }
   async updateThread({
@@ -978,8 +464,8 @@ var InMemoryMemory = class extends MemoryStorage {
     title,
     metadata
   }) {
-    this.logger.debug(`MockStore: updateThread called for ${id}`);
-    const thread = this.collection.threads.get(id);
+    this.logger.debug(`InMemoryMemory: updateThread called for ${id}`);
+    const thread = this.db.threads.get(id);
     if (!thread) {
       throw new Error(`Thread with id ${id} not found`);
     }
@@ -991,11 +477,11 @@ var InMemoryMemory = class extends MemoryStorage {
     return thread;
   }
   async deleteThread({ threadId }) {
-    this.logger.debug(`MockStore: deleteThread called for ${threadId}`);
-    this.collection.threads.delete(threadId);
-    this.collection.messages.forEach((msg, key) => {
+    this.logger.debug(`InMemoryMemory: deleteThread called for ${threadId}`);
+    this.db.threads.delete(threadId);
+    this.db.messages.forEach((msg, key) => {
       if (msg.thread_id === threadId) {
-        this.collection.messages.delete(key);
+        this.db.messages.delete(key);
       }
     });
   }
@@ -1009,7 +495,7 @@ var InMemoryMemory = class extends MemoryStorage {
     orderBy
   }) {
     const threadIds = Array.isArray(threadId) ? threadId : [threadId];
-    this.logger.debug(`MockStore: listMessages called for threads ${threadIds.join(", ")}`);
+    this.logger.debug(`InMemoryMemory: listMessages called for threads ${threadIds.join(", ")}`);
     if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
       throw new Error("threadId must be a non-empty string or array of non-empty strings");
     }
@@ -1024,7 +510,7 @@ var InMemoryMemory = class extends MemoryStorage {
       throw new Error("page value too large");
     }
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-    let threadMessages = Array.from(this.collection.messages.values()).filter((msg) => {
+    let threadMessages = Array.from(this.db.messages.values()).filter((msg) => {
       if (!threadIdSet.has(msg.thread_id)) return false;
       if (resourceId && msg.resourceId !== resourceId) return false;
       return true;
@@ -1062,7 +548,7 @@ var InMemoryMemory = class extends MemoryStorage {
     }
     if (include && include.length > 0) {
       for (const includeItem of include) {
-        const targetMessage = this.collection.messages.get(includeItem.id);
+        const targetMessage = this.db.messages.get(includeItem.id);
         if (targetMessage) {
           const convertedMessage = {
             id: targetMessage.id,
@@ -1078,7 +564,7 @@ var InMemoryMemory = class extends MemoryStorage {
             messageIds.add(convertedMessage.id);
           }
           if (includeItem.withPreviousMessages) {
-            const allThreadMessages = Array.from(this.collection.messages.values()).filter((msg) => msg.thread_id === (includeItem.threadId || threadId)).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            const allThreadMessages = Array.from(this.db.messages.values()).filter((msg) => msg.thread_id === (includeItem.threadId || threadId)).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
             const targetIndex = allThreadMessages.findIndex((msg) => msg.id === includeItem.id);
             if (targetIndex !== -1) {
               const startIndex = Math.max(0, targetIndex - (includeItem.withPreviousMessages || 0));
@@ -1101,7 +587,7 @@ var InMemoryMemory = class extends MemoryStorage {
             }
           }
           if (includeItem.withNextMessages) {
-            const allThreadMessages = Array.from(this.collection.messages.values()).filter((msg) => msg.thread_id === (includeItem.threadId || threadId)).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            const allThreadMessages = Array.from(this.db.messages.values()).filter((msg) => msg.thread_id === (includeItem.threadId || threadId)).sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
             const targetIndex = allThreadMessages.findIndex((msg) => msg.id === includeItem.id);
             if (targetIndex !== -1) {
               const endIndex = Math.min(
@@ -1172,20 +658,23 @@ var InMemoryMemory = class extends MemoryStorage {
     };
   }
   async listMessagesById({ messageIds }) {
-    this.logger.debug(`MockStore: listMessagesById called`);
-    const rawMessages = messageIds.map((id) => this.collection.messages.get(id)).filter((message) => !!message);
-    const list = new MessageList().add(rawMessages.map(this.parseStoredMessage), "memory");
+    this.logger.debug(`InMemoryMemory: listMessagesById called`);
+    const rawMessages = messageIds.map((id) => this.db.messages.get(id)).filter((message) => !!message);
+    const list = new MessageList().add(
+      rawMessages.map((m) => this.parseStoredMessage(m)),
+      "memory"
+    );
     return { messages: list.get.all.db() };
   }
   async saveMessages(args) {
     const { messages } = args;
-    this.logger.debug(`MockStore: saveMessages called with ${messages.length} messages`);
+    this.logger.debug(`InMemoryMemory: saveMessages called with ${messages.length} messages`);
     if (messages.some((msg) => msg.id === "error-message" || msg.resourceId === null)) {
       throw new Error("Simulated error for testing");
     }
     const threadIds = new Set(messages.map((msg) => msg.threadId).filter((id) => Boolean(id)));
     for (const threadId of threadIds) {
-      const thread = this.collection.threads.get(threadId);
+      const thread = this.db.threads.get(threadId);
       if (thread) {
         thread.updatedAt = /* @__PURE__ */ new Date();
       }
@@ -1201,7 +690,7 @@ var InMemoryMemory = class extends MemoryStorage {
         createdAt: message.createdAt,
         resourceId: message.resourceId || null
       };
-      this.collection.messages.set(key, storageMessage);
+      this.db.messages.set(key, storageMessage);
     }
     const list = new MessageList().add(messages, "memory");
     return { messages: list.get.all.db() };
@@ -1209,7 +698,7 @@ var InMemoryMemory = class extends MemoryStorage {
   async updateMessages(args) {
     const updatedMessages = [];
     for (const update of args.messages) {
-      const storageMsg = this.collection.messages.get(update.id);
+      const storageMsg = this.db.messages.get(update.id);
       if (!storageMsg) continue;
       const oldThreadId = storageMsg.thread_id;
       const newThreadId = update.threadId || oldThreadId;
@@ -1236,13 +725,13 @@ var InMemoryMemory = class extends MemoryStorage {
         storageMsg.thread_id = newThreadId;
         const base = Date.now();
         let oldThreadNewTime;
-        const oldThread = this.collection.threads.get(oldThreadId);
+        const oldThread = this.db.threads.get(oldThreadId);
         if (oldThread) {
           const prev = new Date(oldThread.updatedAt).getTime();
           oldThreadNewTime = Math.max(base, prev + 1);
           oldThread.updatedAt = new Date(oldThreadNewTime);
         }
-        const newThread = this.collection.threads.get(newThreadId);
+        const newThread = this.db.threads.get(newThreadId);
         if (newThread) {
           const prev = new Date(newThread.updatedAt).getTime();
           let newThreadNewTime = Math.max(base + 1, prev + 1);
@@ -1252,7 +741,7 @@ var InMemoryMemory = class extends MemoryStorage {
           newThread.updatedAt = new Date(newThreadNewTime);
         }
       } else {
-        const thread = this.collection.threads.get(oldThreadId);
+        const thread = this.db.threads.get(oldThreadId);
         if (thread) {
           const prev = new Date(thread.updatedAt).getTime();
           let newTime = Date.now();
@@ -1260,7 +749,7 @@ var InMemoryMemory = class extends MemoryStorage {
           thread.updatedAt = new Date(newTime);
         }
       }
-      this.collection.messages.set(update.id, storageMsg);
+      this.db.messages.set(update.id, storageMsg);
       updatedMessages.push({
         id: storageMsg.id,
         threadId: storageMsg.thread_id,
@@ -1277,18 +766,18 @@ var InMemoryMemory = class extends MemoryStorage {
     if (!messageIds || messageIds.length === 0) {
       return;
     }
-    this.logger.debug(`MockStore: deleteMessages called for ${messageIds.length} messages`);
+    this.logger.debug(`InMemoryMemory: deleteMessages called for ${messageIds.length} messages`);
     const threadIds = /* @__PURE__ */ new Set();
     for (const messageId of messageIds) {
-      const message = this.collection.messages.get(messageId);
+      const message = this.db.messages.get(messageId);
       if (message && message.thread_id) {
         threadIds.add(message.thread_id);
       }
-      this.collection.messages.delete(messageId);
+      this.db.messages.delete(messageId);
     }
     const now = /* @__PURE__ */ new Date();
     for (const threadId of threadIds) {
-      const thread = this.collection.threads.get(threadId);
+      const thread = this.db.threads.get(threadId);
       if (thread) {
         thread.updatedAt = now;
       }
@@ -1305,8 +794,8 @@ var InMemoryMemory = class extends MemoryStorage {
     if (page * perPage > maxOffset) {
       throw new Error("page value too large");
     }
-    this.logger.debug(`MockStore: listThreadsByResourceId called for ${resourceId}`);
-    const threads = Array.from(this.collection.threads.values()).filter((t) => t.resourceId === resourceId);
+    this.logger.debug(`InMemoryMemory: listThreadsByResourceId called for ${resourceId}`);
+    const threads = Array.from(this.db.threads.values()).filter((t) => t.resourceId === resourceId);
     const sortedThreads = this.sortThreads(threads, field, direction);
     const clonedThreads = sortedThreads.map((thread) => ({
       ...thread,
@@ -1322,13 +811,13 @@ var InMemoryMemory = class extends MemoryStorage {
     };
   }
   async getResourceById({ resourceId }) {
-    this.logger.debug(`MockStore: getResourceById called for ${resourceId}`);
-    const resource = this.collection.resources.get(resourceId);
+    this.logger.debug(`InMemoryMemory: getResourceById called for ${resourceId}`);
+    const resource = this.db.resources.get(resourceId);
     return resource ? { ...resource, metadata: resource.metadata ? { ...resource.metadata } : resource.metadata } : null;
   }
   async saveResource({ resource }) {
-    this.logger.debug(`MockStore: saveResource called for ${resource.id}`);
-    this.collection.resources.set(resource.id, resource);
+    this.logger.debug(`InMemoryMemory: saveResource called for ${resource.id}`);
+    this.db.resources.set(resource.id, resource);
     return resource;
   }
   async updateResource({
@@ -1336,8 +825,8 @@ var InMemoryMemory = class extends MemoryStorage {
     workingMemory,
     metadata
   }) {
-    this.logger.debug(`MockStore: updateResource called for ${resourceId}`);
-    let resource = this.collection.resources.get(resourceId);
+    this.logger.debug(`InMemoryMemory: updateResource called for ${resourceId}`);
+    let resource = this.db.resources.get(resourceId);
     if (!resource) {
       resource = {
         id: resourceId,
@@ -1357,7 +846,7 @@ var InMemoryMemory = class extends MemoryStorage {
         updatedAt: /* @__PURE__ */ new Date()
       };
     }
-    this.collection.resources.set(resourceId, resource);
+    this.db.resources.set(resourceId, resource);
     return resource;
   }
   sortThreads(threads, field, direction) {
@@ -1378,13 +867,15 @@ var InMemoryMemory = class extends MemoryStorage {
 };
 
 // src/storage/domains/observability/base.ts
-var ObservabilityStorage = class extends MastraBase {
+var ObservabilityStorage = class extends StorageDomain {
   constructor() {
     super({
       component: "STORAGE",
       name: "OBSERVABILITY"
     });
   }
+  async dangerouslyClearAll() {
+  }
   /**
    * Provides hints for tracing strategy selection by the DefaultExporter.
    * Storage adapters can override this to specify their preferred and supported strategies.
@@ -1399,7 +890,7 @@ var ObservabilityStorage = class extends MastraBase {
   /**
    * Creates a single Span record in the storage provider.
    */
-  createSpan(_span) {
+  async createSpan(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_CREATE_SPAN_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1410,7 +901,7 @@ var ObservabilityStorage = class extends MastraBase {
   /**
    * Updates a single Span with partial data. Primarily used for realtime trace creation.
    */
-  updateSpan(_params) {
+  async updateSpan(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_STORAGE_UPDATE_SPAN_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1418,10 +909,32 @@ var ObservabilityStorage = class extends MastraBase {
       text: "This storage provider does not support updating spans"
     });
   }
+  /**
+   * Retrieves a single span.
+   */
+  async getSpan(_args) {
+    throw new MastraError({
+      id: "OBSERVABILITY_STORAGE_GET_SPAN_NOT_IMPLEMENTED",
+      domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: "This storage provider does not support getting spans"
+    });
+  }
+  /**
+   * Retrieves a single root span.
+   */
+  async getRootSpan(_args) {
+    throw new MastraError({
+      id: "OBSERVABILITY_STORAGE_GET_ROOT_SPAN_NOT_IMPLEMENTED",
+      domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: "This storage provider does not support getting root spans"
+    });
+  }
   /**
    * Retrieves a single trace with all its associated spans.
    */
-  getTrace(_traceId) {
+  async getTrace(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_STORAGE_GET_TRACE_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1430,20 +943,20 @@ var ObservabilityStorage = class extends MastraBase {
     });
   }
   /**
-   * Retrieves a paginated list of traces with optional filtering.
+   * Retrieves a list of traces with optional filtering.
    */
-  getTracesPaginated(_args) {
+  async listTraces(_args) {
     throw new MastraError({
-      id: "OBSERVABILITY_STORAGE_GET_TRACES_PAGINATED_NOT_IMPLEMENTED",
+      id: "OBSERVABILITY_STORAGE_LIST_TRACES_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
       category: "SYSTEM" /* SYSTEM */,
-      text: "This storage provider does not support getting traces paginated"
+      text: "This storage provider does not support listing traces"
     });
   }
   /**
    * Creates multiple Spans in a single batch.
    */
-  batchCreateSpans(_args) {
+  async batchCreateSpans(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_STORAGE_BATCH_CREATE_SPAN_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1454,7 +967,7 @@ var ObservabilityStorage = class extends MastraBase {
   /**
    * Updates multiple Spans in a single batch.
    */
-  batchUpdateSpans(_args) {
+  async batchUpdateSpans(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_STORAGE_BATCH_UPDATE_SPANS_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1465,7 +978,7 @@ var ObservabilityStorage = class extends MastraBase {
   /**
    * Deletes multiple traces and all their associated spans in a single batch operation.
    */
-  batchDeleteTraces(_args) {
+  async batchDeleteTraces(_args) {
     throw new MastraError({
       id: "OBSERVABILITY_STORAGE_BATCH_DELETE_TRACES_NOT_IMPLEMENTED",
       domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
@@ -1477,12 +990,13 @@ var ObservabilityStorage = class extends MastraBase {
 
 // src/storage/domains/observability/inmemory.ts
 var ObservabilityInMemory = class extends ObservabilityStorage {
-  operations;
-  collection;
-  constructor({ collection, operations }) {
+  db;
+  constructor({ db }) {
     super();
-    this.collection = collection;
-    this.operations = operations;
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.traces.clear();
   }
   get tracingStrategy() {
     return {
@@ -1490,17 +1004,27 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
       supported: ["realtime", "batch-with-updates", "insert-only"]
     };
   }
-  async createSpan(span) {
+  async createSpan(args) {
+    const { span } = args;
     this.validateCreateSpan(span);
-    const id = this.generateId(span);
-    const record = span;
-    record.createdAt = /* @__PURE__ */ new Date();
-    record.updatedAt = record.createdAt;
-    this.collection.set(id, record);
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      ...span,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.upsertSpanToTrace(record);
   }
   async batchCreateSpans(args) {
-    for (const record of args.records) {
-      await this.createSpan(record);
+    const now = /* @__PURE__ */ new Date();
+    for (const span of args.records) {
+      this.validateCreateSpan(span);
+      const record = {
+        ...span,
+        createdAt: now,
+        updatedAt: now
+      };
+      this.upsertSpanToTrace(record);
     }
   }
   validateCreateSpan(record) {
@@ -1521,11 +1045,74 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
       });
     }
   }
-  generateId({ traceId, spanId }) {
-    return `${traceId}-${spanId}`;
+  /**
+   * Inserts or updates a span in the trace and recomputes trace-level properties
+   */
+  upsertSpanToTrace(span) {
+    const { traceId, spanId } = span;
+    let traceEntry = this.db.traces.get(traceId);
+    if (!traceEntry) {
+      traceEntry = {
+        spans: {},
+        rootSpan: null,
+        status: "running" /* RUNNING */,
+        hasChildError: false
+      };
+      this.db.traces.set(traceId, traceEntry);
+    }
+    traceEntry.spans[spanId] = span;
+    if (span.parentSpanId === null) {
+      traceEntry.rootSpan = span;
+    }
+    this.recomputeTraceProperties(traceEntry);
+  }
+  /**
+   * Recomputes derived trace properties from all spans
+   */
+  recomputeTraceProperties(traceEntry) {
+    const spans = Object.values(traceEntry.spans);
+    if (spans.length === 0) return;
+    traceEntry.hasChildError = spans.some((s) => s.error != null);
+    const rootSpan = traceEntry.rootSpan;
+    if (rootSpan) {
+      if (rootSpan.error != null) {
+        traceEntry.status = "error" /* ERROR */;
+      } else if (rootSpan.endedAt === null) {
+        traceEntry.status = "running" /* RUNNING */;
+      } else {
+        traceEntry.status = "success" /* SUCCESS */;
+      }
+    } else {
+      traceEntry.status = "running" /* RUNNING */;
+    }
+  }
+  async getSpan(args) {
+    const { traceId, spanId } = args;
+    const traceEntry = this.db.traces.get(traceId);
+    if (!traceEntry) {
+      return null;
+    }
+    const span = traceEntry.spans[spanId];
+    if (!span) {
+      return null;
+    }
+    return { span };
+  }
+  async getRootSpan(args) {
+    const { traceId } = args;
+    const traceEntry = this.db.traces.get(traceId);
+    if (!traceEntry || !traceEntry.rootSpan) {
+      return null;
+    }
+    return { span: traceEntry.rootSpan };
   }
-  async getTrace(traceId) {
-    const spans = Array.from(this.collection.values()).filter((span) => span.traceId === traceId);
+  async getTrace(args) {
+    const { traceId } = args;
+    const traceEntry = this.db.traces.get(traceId);
+    if (!traceEntry) {
+      return null;
+    }
+    const spans = Object.values(traceEntry.spans);
     if (spans.length === 0) {
       return null;
     }
@@ -1535,272 +1122,233 @@ var ObservabilityInMemory = class extends ObservabilityStorage {
       spans
     };
   }
-  async getTracesPaginated({
-    filters,
-    pagination
-  }) {
-    const allRootSpans = this.filterForRootSpans(Array.from(this.collection.values()));
-    const filteredRootSpans = this.filterSpansByFilter(allRootSpans, filters);
-    const startDate = pagination?.dateRange?.start;
-    const endDate = pagination?.dateRange?.end;
-    const filteredRootSpansByDate = this.filterSpansByDate(filteredRootSpans, startDate, endDate);
-    const total = filteredRootSpansByDate.length;
-    const page = pagination?.page ?? 0;
-    const perPage = pagination?.perPage ?? 10;
+  async listTraces(args) {
+    const { filters, pagination, orderBy } = listTracesArgsSchema.parse(args);
+    const matchingRootSpans = [];
+    for (const [, traceEntry] of this.db.traces) {
+      if (!traceEntry.rootSpan) continue;
+      if (this.traceMatchesFilters(traceEntry, filters)) {
+        matchingRootSpans.push(traceEntry.rootSpan);
+      }
+    }
+    const { field: sortField, direction: sortDirection } = orderBy;
+    matchingRootSpans.sort((a, b) => {
+      if (sortField === "endedAt") {
+        const aVal = a.endedAt;
+        const bVal = b.endedAt;
+        if (aVal == null && bVal == null) return 0;
+        if (aVal == null) return sortDirection === "DESC" ? -1 : 1;
+        if (bVal == null) return sortDirection === "DESC" ? 1 : -1;
+        const diff = aVal.getTime() - bVal.getTime();
+        return sortDirection === "DESC" ? -diff : diff;
+      } else {
+        const diff = a.startedAt.getTime() - b.startedAt.getTime();
+        return sortDirection === "DESC" ? -diff : diff;
+      }
+    });
+    const total = matchingRootSpans.length;
+    const { page, perPage } = pagination;
     const start = page * perPage;
     const end = start + perPage;
-    const paged = this.filterSpansByPagination(filteredRootSpansByDate, pagination);
+    const paged = matchingRootSpans.slice(start, end);
     return {
       spans: paged,
       pagination: { total, page, perPage, hasMore: end < total }
     };
   }
-  filterForRootSpans(spans) {
-    return spans.filter((span) => span.parentSpanId === null);
-  }
-  filterSpansByDate(spans, startDate, endDate) {
-    return spans.filter((span) => {
-      if (startDate && span.startedAt < startDate) return false;
-      if (endDate && span.startedAt > endDate) return false;
-      return true;
-    });
-  }
-  filterSpansByFilter(spans, filter) {
-    return spans.filter((span) => {
-      if (filter?.name && span.name !== filter.name) return false;
-      if (filter?.spanType && span.spanType !== filter.spanType) return false;
-      if (filter?.entityType === "agent" && filter.entityId !== span.attributes?.agentId) return false;
-      if (filter?.entityType === "workflow" && filter.entityId !== span.attributes?.workflowId) return false;
-      return true;
-    });
-  }
-  filterSpansByPagination(spans, pagination) {
-    const page = pagination?.page ?? 0;
-    const perPage = pagination?.perPage ?? 10;
-    const start = page * perPage;
-    const end = start + perPage;
-    return spans.slice(start, end);
-  }
-  async updateSpan(params) {
-    const id = this.generateId(params);
-    const span = this.collection.get(id);
-    if (!span) {
-      throw new MastraError({
-        id: "OBSERVABILITY_UPDATE_SPAN_NOT_FOUND",
-        domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
-        category: "SYSTEM" /* SYSTEM */,
-        text: "Span not found for update"
-      });
+  /**
+   * Check if a trace matches all provided filters
+   */
+  traceMatchesFilters(traceEntry, filters) {
+    if (!filters) return true;
+    const rootSpan = traceEntry.rootSpan;
+    if (!rootSpan) return false;
+    if (filters.startedAt) {
+      if (filters.startedAt.start && rootSpan.startedAt < filters.startedAt.start) {
+        return false;
+      }
+      if (filters.startedAt.end && rootSpan.startedAt > filters.startedAt.end) {
+        return false;
+      }
     }
-    this.collection.set(id, { ...span, ...params.updates, updatedAt: /* @__PURE__ */ new Date() });
-  }
-  async batchUpdateSpans(args) {
-    for (const record of args.records) {
-      await this.updateSpan(record);
+    if (filters.endedAt) {
+      if (rootSpan.endedAt == null) {
+        return false;
+      }
+      if (filters.endedAt.start && rootSpan.endedAt < filters.endedAt.start) {
+        return false;
+      }
+      if (filters.endedAt.end && rootSpan.endedAt > filters.endedAt.end) {
+        return false;
+      }
     }
-  }
-  async batchDeleteTraces(args) {
-    for (const traceId of args.traceIds) {
-      const spans = Array.from(this.collection.values()).filter((span) => span.traceId === traceId);
-      for (const span of spans) {
-        this.collection.delete(this.generateId(span));
+    if (filters.spanType !== void 0 && rootSpan.spanType !== filters.spanType) {
+      return false;
+    }
+    if (filters.entityType !== void 0 && rootSpan.entityType !== filters.entityType) {
+      return false;
+    }
+    if (filters.entityId !== void 0 && rootSpan.entityId !== filters.entityId) {
+      return false;
+    }
+    if (filters.entityName !== void 0 && rootSpan.entityName !== filters.entityName) {
+      return false;
+    }
+    if (filters.userId !== void 0 && rootSpan.userId !== filters.userId) {
+      return false;
+    }
+    if (filters.organizationId !== void 0 && rootSpan.organizationId !== filters.organizationId) {
+      return false;
+    }
+    if (filters.resourceId !== void 0 && rootSpan.resourceId !== filters.resourceId) {
+      return false;
+    }
+    if (filters.runId !== void 0 && rootSpan.runId !== filters.runId) {
+      return false;
+    }
+    if (filters.sessionId !== void 0 && rootSpan.sessionId !== filters.sessionId) {
+      return false;
+    }
+    if (filters.threadId !== void 0 && rootSpan.threadId !== filters.threadId) {
+      return false;
+    }
+    if (filters.requestId !== void 0 && rootSpan.requestId !== filters.requestId) {
+      return false;
+    }
+    if (filters.environment !== void 0 && rootSpan.environment !== filters.environment) {
+      return false;
+    }
+    if (filters.source !== void 0 && rootSpan.source !== filters.source) {
+      return false;
+    }
+    if (filters.serviceName !== void 0 && rootSpan.serviceName !== filters.serviceName) {
+      return false;
+    }
+    if (filters.scope != null && rootSpan.scope != null) {
+      for (const [key, value] of Object.entries(filters.scope)) {
+        if (!this.jsonValueEquals(rootSpan.scope[key], value)) {
+          return false;
+        }
       }
+    } else if (filters.scope != null && rootSpan.scope == null) {
+      return false;
     }
-  }
-};
-
-// src/storage/domains/operations/base.ts
-var StoreOperations = class extends MastraBase {
-  constructor() {
-    super({
-      component: "STORAGE",
-      name: "OPERATIONS"
-    });
-  }
-  getSqlType(type) {
-    switch (type) {
-      case "text":
-        return "TEXT";
-      case "timestamp":
-        return "TIMESTAMP";
-      case "float":
-        return "FLOAT";
-      case "integer":
-        return "INTEGER";
-      case "bigint":
-        return "BIGINT";
-      case "jsonb":
-        return "JSONB";
-      default:
-        return "TEXT";
+    if (filters.metadata != null && rootSpan.metadata != null) {
+      for (const [key, value] of Object.entries(filters.metadata)) {
+        if (!this.jsonValueEquals(rootSpan.metadata[key], value)) {
+          return false;
+        }
+      }
+    } else if (filters.metadata != null && rootSpan.metadata == null) {
+      return false;
     }
-  }
-  getDefaultValue(type) {
-    switch (type) {
-      case "text":
-      case "uuid":
-        return "DEFAULT ''";
-      case "timestamp":
-        return "DEFAULT '1970-01-01 00:00:00'";
-      case "integer":
-      case "bigint":
-      case "float":
-        return "DEFAULT 0";
-      case "jsonb":
-        return "DEFAULT '{}'";
-      default:
-        return "DEFAULT ''";
+    if (filters.tags != null && filters.tags.length > 0) {
+      if (rootSpan.tags == null) {
+        return false;
+      }
+      for (const tag of filters.tags) {
+        if (!rootSpan.tags.includes(tag)) {
+          return false;
+        }
+      }
     }
+    if (filters.status !== void 0 && traceEntry.status !== filters.status) {
+      return false;
+    }
+    if (filters.hasChildError !== void 0 && traceEntry.hasChildError !== filters.hasChildError) {
+      return false;
+    }
+    return true;
   }
   /**
-   * DATABASE INDEX MANAGEMENT
-   * Optional methods for database index management.
-   * Storage adapters can override these to provide index management capabilities.
-   */
-  /**
-   * Creates a database index on specified columns
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async createIndex(_options) {
-    throw new MastraError({
-      id: "MASTRA_STORAGE_CREATE_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter`
-    });
-  }
-  /**
-   * Drops a database index by name
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async dropIndex(_indexName) {
-    throw new MastraError({
-      id: "MASTRA_STORAGE_DROP_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter`
-    });
-  }
-  /**
-   * Lists database indexes for a table or all tables
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async listIndexes(_tableName) {
-    throw new MastraError({
-      id: "MASTRA_STORAGE_LIST_INDEXES_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter`
-    });
-  }
-  /**
-   * Gets detailed statistics for a specific index
-   * @throws {MastraError} if not supported by the storage adapter
-   */
-  async describeIndex(_indexName) {
-    throw new MastraError({
-      id: "MASTRA_STORAGE_DESCRIBE_INDEX_NOT_SUPPORTED",
-      domain: "STORAGE" /* STORAGE */,
-      category: "SYSTEM" /* SYSTEM */,
-      text: `Index management is not supported by this storage adapter`
-    });
-  }
-  /**
-   * Returns definitions for automatic performance indexes
-   * Storage adapters can override this to define indexes that should be created during initialization
-   * @returns Array of index definitions to create automatically
+   * Deep equality check for JSON values
    */
-  getAutomaticIndexDefinitions() {
-    return [];
-  }
-};
-
-// src/storage/domains/operations/inmemory.ts
-var StoreOperationsInMemory = class extends StoreOperations {
-  data;
-  constructor() {
-    super();
-    this.data = {
-      mastra_workflow_snapshot: /* @__PURE__ */ new Map(),
-      mastra_messages: /* @__PURE__ */ new Map(),
-      mastra_threads: /* @__PURE__ */ new Map(),
-      mastra_traces: /* @__PURE__ */ new Map(),
-      mastra_resources: /* @__PURE__ */ new Map(),
-      mastra_scorers: /* @__PURE__ */ new Map(),
-      mastra_ai_spans: /* @__PURE__ */ new Map(),
-      mastra_agents: /* @__PURE__ */ new Map()
-    };
-  }
-  getDatabase() {
-    return this.data;
-  }
-  async insert({ tableName, record }) {
-    const table = this.data[tableName];
-    let key = record.id;
-    if ([TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
-      key = record.workflow_name ? `${record.workflow_name}-${record.run_id}` : record.run_id;
-      record.id = key;
-    } else if (!record.id) {
-      key = `auto-${Date.now()}-${Math.random()}`;
-      record.id = key;
+  jsonValueEquals(a, b) {
+    if (a === void 0 || b === void 0) {
+      return a === b;
     }
-    table.set(key, record);
-  }
-  async batchInsert({ tableName, records }) {
-    const table = this.data[tableName];
-    for (const record of records) {
-      let key = record.id;
-      if ([TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
-        key = record.run_id;
-        record.id = key;
-      } else if (!record.id) {
-        key = `auto-${Date.now()}-${Math.random()}`;
-        record.id = key;
+    if (a === null || b === null) {
+      return a === b;
+    }
+    if (typeof a !== typeof b) {
+      return false;
+    }
+    if (a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
+    if (a instanceof Date || b instanceof Date) {
+      return false;
+    }
+    if (typeof a === "object") {
+      if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length) return false;
+        return a.every((val, i) => this.jsonValueEquals(val, b[i]));
       }
-      table.set(key, record);
+      if (Array.isArray(a) || Array.isArray(b)) {
+        return false;
+      }
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length) return false;
+      return aKeys.every(
+        (key) => this.jsonValueEquals(a[key], b[key])
+      );
     }
+    return a === b;
   }
-  async load({ tableName, keys }) {
-    this.logger.debug(`MockStore: load called for ${tableName} with keys`, keys);
-    const table = this.data[tableName];
-    const records = Array.from(table.values());
-    return records.filter((record) => Object.keys(keys).every((key) => record[key] === keys[key]))?.[0];
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    this.logger.debug(`MockStore: createTable called for ${tableName} with schema`, schema);
-    this.data[tableName] = /* @__PURE__ */ new Map();
-  }
-  async clearTable({ tableName }) {
-    this.logger.debug(`MockStore: clearTable called for ${tableName}`);
-    this.data[tableName].clear();
-  }
-  async dropTable({ tableName }) {
-    this.logger.debug(`MockStore: dropTable called for ${tableName}`);
-    this.data[tableName].clear();
+  async updateSpan(args) {
+    const { traceId, spanId, updates } = args;
+    const traceEntry = this.db.traces.get(traceId);
+    if (!traceEntry) {
+      throw new MastraError({
+        id: "OBSERVABILITY_UPDATE_SPAN_NOT_FOUND",
+        domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+        category: "SYSTEM" /* SYSTEM */,
+        text: "Trace not found for span update"
+      });
+    }
+    const span = traceEntry.spans[spanId];
+    if (!span) {
+      throw new MastraError({
+        id: "OBSERVABILITY_UPDATE_SPAN_NOT_FOUND",
+        domain: "MASTRA_OBSERVABILITY" /* MASTRA_OBSERVABILITY */,
+        category: "SYSTEM" /* SYSTEM */,
+        text: "Span not found for update"
+      });
+    }
+    const updatedSpan = {
+      ...span,
+      ...updates,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    traceEntry.spans[spanId] = updatedSpan;
+    if (updatedSpan.parentSpanId === null) {
+      traceEntry.rootSpan = updatedSpan;
+    }
+    this.recomputeTraceProperties(traceEntry);
   }
-  async alterTable({
-    tableName,
-    schema
-  }) {
-    this.logger.debug(`MockStore: alterTable called for ${tableName} with schema`, schema);
+  async batchUpdateSpans(args) {
+    for (const record of args.records) {
+      await this.updateSpan(record);
+    }
   }
-  async hasColumn(table, column) {
-    this.logger.debug(`MockStore: hasColumn called for ${table} with column ${column}`);
-    return true;
+  async batchDeleteTraces(args) {
+    for (const traceId of args.traceIds) {
+      this.db.traces.delete(traceId);
+    }
   }
 };
 
 // src/storage/domains/scores/base.ts
-var ScoresStorage = class extends MastraBase {
+var ScoresStorage = class extends StorageDomain {
   constructor() {
     super({
       component: "STORAGE",
       name: "SCORES"
     });
   }
+  async dangerouslyClearAll() {
+  }
   async listScoresBySpan({
     traceId,
     spanId,
@@ -1817,17 +1365,20 @@ var ScoresStorage = class extends MastraBase {
 
 // src/storage/domains/scores/inmemory.ts
 var ScoresInMemory = class extends ScoresStorage {
-  scores;
-  constructor({ collection }) {
+  db;
+  constructor({ db }) {
     super();
-    this.scores = collection;
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.scores.clear();
   }
   async getScoreById({ id }) {
-    return this.scores.get(id) ?? null;
+    return this.db.scores.get(id) ?? null;
   }
   async saveScore(score) {
     const newScore = { id: crypto.randomUUID(), createdAt: /* @__PURE__ */ new Date(), updatedAt: /* @__PURE__ */ new Date(), ...score };
-    this.scores.set(newScore.id, newScore);
+    this.db.scores.set(newScore.id, newScore);
     return { score: newScore };
   }
   async listScoresByScorerId({
@@ -1837,7 +1388,7 @@ var ScoresInMemory = class extends ScoresStorage {
     entityType,
     source
   }) {
-    const scores = Array.from(this.scores.values()).filter((score) => {
+    const scores = Array.from(this.db.scores.values()).filter((score) => {
       let baseFilter = score.scorerId === scorerId;
       if (entityId) {
         baseFilter = baseFilter && score.entityId === entityId;
@@ -1868,7 +1419,7 @@ var ScoresInMemory = class extends ScoresStorage {
     runId,
     pagination
   }) {
-    const scores = Array.from(this.scores.values()).filter((score) => score.runId === runId);
+    const scores = Array.from(this.db.scores.values()).filter((score) => score.runId === runId);
     const { page, perPage: perPageInput } = pagination;
     const perPage = normalizePerPage(perPageInput, Number.MAX_SAFE_INTEGER);
     const { offset: start, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
@@ -1888,7 +1439,7 @@ var ScoresInMemory = class extends ScoresStorage {
     entityType,
     pagination
   }) {
-    const scores = Array.from(this.scores.values()).filter((score) => {
+    const scores = Array.from(this.db.scores.values()).filter((score) => {
       const baseFilter = score.entityId === entityId && score.entityType === entityType;
       return baseFilter;
     });
@@ -1911,7 +1462,7 @@ var ScoresInMemory = class extends ScoresStorage {
     spanId,
     pagination
   }) {
-    const scores = Array.from(this.scores.values()).filter(
+    const scores = Array.from(this.db.scores.values()).filter(
       (score) => score.traceId === traceId && score.spanId === spanId
     );
     scores.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
@@ -1932,7 +1483,7 @@ var ScoresInMemory = class extends ScoresStorage {
 };
 
 // src/storage/domains/workflows/base.ts
-var WorkflowsStorage = class extends MastraBase {
+var WorkflowsStorage = class extends StorageDomain {
   constructor() {
     super({
       component: "STORAGE",
@@ -1943,12 +1494,16 @@ var WorkflowsStorage = class extends MastraBase {
 
 // src/storage/domains/workflows/inmemory.ts
 var WorkflowsInMemory = class extends WorkflowsStorage {
-  operations;
-  collection;
-  constructor({ collection, operations }) {
+  db;
+  constructor({ db }) {
     super();
-    this.collection = collection;
-    this.operations = operations;
+    this.db = db;
+  }
+  async dangerouslyClearAll() {
+    this.db.workflows.clear();
+  }
+  getWorkflowKey(workflowName, runId) {
+    return `${workflowName}-${runId}`;
   }
   async updateWorkflowResults({
     workflowName,
@@ -1957,8 +1512,9 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     result,
     requestContext
   }) {
-    this.logger.debug(`MockStore: updateWorkflowResults called for ${workflowName} ${runId} ${stepId}`, result);
-    const run = this.collection.get(`${workflowName}-${runId}`);
+    this.logger.debug(`WorkflowsInMemory: updateWorkflowResults called for ${workflowName} ${runId} ${stepId}`, result);
+    const key = this.getWorkflowKey(workflowName, runId);
+    const run = this.db.workflows.get(key);
     if (!run) {
       return {};
     }
@@ -1977,18 +1533,19 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
         status: "pending",
         runId: run.run_id
       };
-      this.collection.set(`${workflowName}-${runId}`, {
+      this.db.workflows.set(key, {
         ...run,
         snapshot
       });
+    } else {
+      snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
     }
-    snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
     if (!snapshot || !snapshot?.context) {
       throw new Error(`Snapshot not found for runId ${runId}`);
     }
     snapshot.context[stepId] = result;
     snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
-    this.collection.set(`${workflowName}-${runId}`, {
+    this.db.workflows.set(key, {
       ...run,
       snapshot
     });
@@ -1999,7 +1556,8 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     runId,
     opts
   }) {
-    const run = this.collection.get(`${workflowName}-${runId}`);
+    const key = this.getWorkflowKey(workflowName, runId);
+    const run = this.db.workflows.get(key);
     if (!run) {
       return;
     }
@@ -2018,7 +1576,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
         status: "pending",
         runId: run.run_id
       };
-      this.collection.set(`${workflowName}-${runId}`, {
+      this.db.workflows.set(key, {
         ...run,
         snapshot
       });
@@ -2029,7 +1587,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
       throw new Error(`Snapshot not found for runId ${runId}`);
     }
     snapshot = { ...snapshot, ...opts };
-    this.collection.set(`${workflowName}-${runId}`, {
+    this.db.workflows.set(key, {
       ...run,
       snapshot
     });
@@ -2039,31 +1597,34 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     workflowName,
     runId,
     resourceId,
-    snapshot
+    snapshot,
+    createdAt,
+    updatedAt
   }) {
+    const key = this.getWorkflowKey(workflowName, runId);
+    const now = /* @__PURE__ */ new Date();
     const data = {
       workflow_name: workflowName,
       run_id: runId,
       resourceId,
       snapshot,
-      createdAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
+      createdAt: createdAt ?? now,
+      updatedAt: updatedAt ?? now
     };
-    await this.operations.insert({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      record: data
-    });
+    this.db.workflows.set(key, data);
   }
   async loadWorkflowSnapshot({
     workflowName,
     runId
   }) {
     this.logger.debug("Loading workflow snapshot", { workflowName, runId });
-    const d = await this.operations.load({
-      tableName: TABLE_WORKFLOW_SNAPSHOT,
-      keys: { workflow_name: workflowName, run_id: runId }
-    });
-    return d ? JSON.parse(JSON.stringify(d.snapshot)) : null;
+    const key = this.getWorkflowKey(workflowName, runId);
+    const run = this.db.workflows.get(key);
+    if (!run) {
+      return null;
+    }
+    const snapshot = typeof run.snapshot === "string" ? JSON.parse(run.snapshot) : run.snapshot;
+    return snapshot ? JSON.parse(JSON.stringify(snapshot)) : null;
   }
   async listWorkflowRuns({
     workflowName,
@@ -2077,7 +1638,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     if (page !== void 0 && page < 0) {
       throw new Error("page must be >= 0");
     }
-    let runs = Array.from(this.collection.values());
+    let runs = Array.from(this.db.workflows.values());
     if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
     if (status) {
       runs = runs.filter((run) => {
@@ -2131,7 +1692,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     runId,
     workflowName
   }) {
-    const runs = Array.from(this.collection.values()).filter((r) => r.run_id === runId);
+    const runs = Array.from(this.db.workflows.values()).filter((r) => r.run_id === runId);
     let run = runs.find((r) => r.workflow_name === workflowName);
     if (!run) return null;
     const parsedRun = {
@@ -2146,227 +1707,227 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     return parsedRun;
   }
   async deleteWorkflowRunById({ runId, workflowName }) {
-    this.collection.delete(`${workflowName}-${runId}`);
+    const key = this.getWorkflowKey(workflowName, runId);
+    this.db.workflows.delete(key);
   }
 };
 
 // src/storage/mock.ts
 var InMemoryStore = class extends MastraStorage {
   stores;
+  /**
+   * Internal database layer shared across all domains.
+   * This is an implementation detail - domains interact with this
+   * rather than managing their own data structures.
+   */
+  #db;
   constructor({ id = "in-memory" } = {}) {
     super({ id, name: "InMemoryStorage" });
     this.hasInitialized = Promise.resolve(true);
-    const operationsStorage = new StoreOperationsInMemory();
-    const database = operationsStorage.getDatabase();
-    const scoresStorage = new ScoresInMemory({
-      collection: database.mastra_scorers
-    });
-    const workflowsStorage = new WorkflowsInMemory({
-      collection: database.mastra_workflow_snapshot,
-      operations: operationsStorage
-    });
-    const memoryStorage = new InMemoryMemory({
-      collection: {
-        threads: database.mastra_threads,
-        resources: database.mastra_resources,
-        messages: database.mastra_messages
-      },
-      operations: operationsStorage
-    });
-    const observabilityStorage = new ObservabilityInMemory({
-      collection: database.mastra_ai_spans,
-      operations: operationsStorage
-    });
-    const agentsCollection = /* @__PURE__ */ new Map();
-    const agentsStorage = new InMemoryAgentsStorage({
-      collection: agentsCollection
-    });
+    this.#db = new InMemoryDB();
     this.stores = {
-      operations: operationsStorage,
-      workflows: workflowsStorage,
-      scores: scoresStorage,
-      memory: memoryStorage,
-      observability: observabilityStorage,
-      agents: agentsStorage
-    };
-  }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: false,
-      resourceWorkingMemory: false,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: true,
-      observabilityInstance: true,
-      indexManagement: false,
-      listScoresBySpan: true,
-      agents: true
+      memory: new InMemoryMemory({ db: this.#db }),
+      workflows: new WorkflowsInMemory({ db: this.#db }),
+      scores: new ScoresInMemory({ db: this.#db }),
+      observability: new ObservabilityInMemory({ db: this.#db }),
+      agents: new InMemoryAgentsStorage({ db: this.#db })
     };
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    await this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    await this.stores.operations.createTable({ tableName, schema });
-  }
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    await this.stores.operations.alterTable({ tableName, schema, ifNotExists });
-  }
-  async clearTable({ tableName }) {
-    await this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    await this.stores.operations.dropTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    await this.stores.operations.insert({ tableName, record });
-  }
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async batchInsert({ tableName, records }) {
-    await this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
+  /**
+   * Clears all data from the in-memory database.
+   * Useful for testing.
+   * @deprecated Use dangerouslyClearAll() on individual domains instead.
+   */
+  clear() {
+    this.#db.clear();
   }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
+};
+var MockStore = InMemoryStore;
+
+// src/storage/domains/operations/base.ts
+var StoreOperations = class extends MastraBase {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "OPERATIONS"
+    });
   }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "float":
+        return "FLOAT";
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "BIGINT";
+      case "jsonb":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
   }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
+  getDefaultValue(type) {
+    switch (type) {
+      case "text":
+      case "uuid":
+        return "DEFAULT ''";
+      case "timestamp":
+        return "DEFAULT '1970-01-01 00:00:00'";
+      case "integer":
+      case "bigint":
+      case "float":
+        return "DEFAULT 0";
+      case "jsonb":
+        return "DEFAULT '{}'";
+      default:
+        return "DEFAULT ''";
+    }
   }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
+  /**
+   * DATABASE INDEX MANAGEMENT
+   * Optional methods for database index management.
+   * Storage adapters can override these to provide index management capabilities.
+   */
+  /**
+   * Creates a database index on specified columns
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async createIndex(_options) {
+    throw new MastraError({
+      id: "MASTRA_STORAGE_CREATE_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter`
+    });
   }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
+  /**
+   * Drops a database index by name
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async dropIndex(_indexName) {
+    throw new MastraError({
+      id: "MASTRA_STORAGE_DROP_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter`
+    });
   }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  /**
+   * Lists database indexes for a table or all tables
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async listIndexes(_tableName) {
+    throw new MastraError({
+      id: "MASTRA_STORAGE_LIST_INDEXES_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter`
+    });
   }
-  async listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
+  /**
+   * Gets detailed statistics for a specific index
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async describeIndex(_indexName) {
+    throw new MastraError({
+      id: "MASTRA_STORAGE_DESCRIBE_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter`
+    });
   }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
+  /**
+   * Returns definitions for automatic performance indexes
+   * Storage adapters can override this to define indexes that should be created during initialization
+   * @returns Array of index definitions to create automatically
+   */
+  getAutomaticIndexDefinitions() {
+    return [];
   }
-  async updateMessages(args) {
-    return this.stores.memory.updateMessages(args);
+};
+
+// src/storage/domains/operations/inmemory.ts
+var StoreOperationsInMemory = class extends StoreOperations {
+  data;
+  constructor() {
+    super();
+    this.data = {
+      mastra_workflow_snapshot: /* @__PURE__ */ new Map(),
+      mastra_messages: /* @__PURE__ */ new Map(),
+      mastra_threads: /* @__PURE__ */ new Map(),
+      mastra_traces: /* @__PURE__ */ new Map(),
+      mastra_resources: /* @__PURE__ */ new Map(),
+      mastra_scorers: /* @__PURE__ */ new Map(),
+      mastra_ai_spans: /* @__PURE__ */ new Map(),
+      mastra_agents: /* @__PURE__ */ new Map()
+    };
   }
-  async deleteMessages(messageIds) {
-    return this.stores.memory.deleteMessages(messageIds);
+  getDatabase() {
+    return this.data;
   }
-  async getScoreById({ id }) {
-    return this.stores.scores.getScoreById({ id });
+  async insert({ tableName, record }) {
+    const table = this.data[tableName];
+    let key = record.id;
+    if ([TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+      key = record.workflow_name ? `${record.workflow_name}-${record.run_id}` : record.run_id;
+      record.id = key;
+    } else if (!record.id) {
+      key = `auto-${Date.now()}-${Math.random()}`;
+      record.id = key;
+    }
+    table.set(key, record);
   }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
+  async batchInsert({ tableName, records }) {
+    const table = this.data[tableName];
+    for (const record of records) {
+      let key = record.id;
+      if ([TABLE_WORKFLOW_SNAPSHOT].includes(tableName) && !record.id && record.run_id) {
+        key = record.run_id;
+        record.id = key;
+      } else if (!record.id) {
+        key = `auto-${Date.now()}-${Math.random()}`;
+        record.id = key;
+      }
+      table.set(key, record);
+    }
   }
-  async listScoresByScorerId({
-    scorerId,
-    entityId,
-    entityType,
-    source,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByScorerId({ scorerId, entityId, entityType, source, pagination });
+  async load({ tableName, keys }) {
+    this.logger.debug(`MockStore: load called for ${tableName} with keys`, keys);
+    const table = this.data[tableName];
+    const records = Array.from(table.values());
+    return records.filter((record) => Object.keys(keys).every((key) => record[key] === keys[key]))?.[0];
   }
-  async listScoresByRunId({
-    runId,
-    pagination
+  async createTable({
+    tableName,
+    schema
   }) {
-    return this.stores.scores.listScoresByRunId({ runId, pagination });
+    this.logger.debug(`MockStore: createTable called for ${tableName} with schema`, schema);
+    this.data[tableName] = /* @__PURE__ */ new Map();
   }
-  async listScoresByEntityId({
-    entityId,
-    entityType,
-    pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({ entityId, entityType, pagination });
+  async clearTable({ tableName }) {
+    this.logger.debug(`MockStore: clearTable called for ${tableName}`);
+    this.data[tableName].clear();
   }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination });
+  async dropTable({ tableName }) {
+    this.logger.debug(`MockStore: dropTable called for ${tableName}`);
+    this.data[tableName].clear();
   }
-  async getWorkflowRunById({
-    runId,
-    workflowName
+  async alterTable({
+    tableName,
+    schema
   }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
-  async createSpan(span) {
-    return this.stores.observability.createSpan(span);
-  }
-  async updateSpan(params) {
-    return this.stores.observability.updateSpan(params);
-  }
-  async getTrace(traceId) {
-    return this.stores.observability.getTrace(traceId);
-  }
-  async batchCreateSpans(args) {
-    return this.stores.observability.batchCreateSpans(args);
-  }
-  async batchUpdateSpans(args) {
-    return this.stores.observability.batchUpdateSpans(args);
+    this.logger.debug(`MockStore: alterTable called for ${tableName} with schema`, schema);
   }
-  async batchDeleteTraces(args) {
-    return this.stores.observability.batchDeleteTraces(args);
+  async hasColumn(table, column) {
+    this.logger.debug(`MockStore: hasColumn called for ${table} with column ${column}`);
+    return true;
   }
 };
-var MockStore = InMemoryStore;
 
-export { AGENTS_SCHEMA, AgentsStorage, InMemoryAgentsStorage, InMemoryMemory, InMemoryStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, SCORERS_SCHEMA, SPAN_SCHEMA, ScoresInMemory, ScoresStorage, StoreOperations, StoreOperationsInMemory, TABLE_AGENTS, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEMAS, TABLE_SCORERS, TABLE_SPANS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
-//# sourceMappingURL=chunk-GBQXIVL6.js.map
-//# sourceMappingURL=chunk-GBQXIVL6.js.map
+export { AgentsStorage, InMemoryAgentsStorage, InMemoryDB, InMemoryMemory, InMemoryStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, ScoresInMemory, ScoresStorage, StorageDomain, StoreOperations, StoreOperationsInMemory, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, getDefaultValue, getSqlType, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
+//# sourceMappingURL=chunk-GNUITL2N.js.map
+//# sourceMappingURL=chunk-GNUITL2N.js.map