@mastra/core 1.2.0-alpha.0 → 1.2.0

package/dist/{chunk-OQPAOUDS.js → chunk-ZODRDMZ7.js}

@@ -1,6 +1,6 @@
-import { MessageList } from './chunk-HIP5W3LZ.js';
-import { TABLE_SCHEMAS, TABLE_SCORERS, listTracesArgsSchema, toTraceSpans, TABLE_WORKFLOW_SNAPSHOT } from './chunk-CILDTRXD.js';
-import { deepEqual } from './chunk-4DDIPGB6.js';
+import { MessageList } from './chunk-57O4TPB3.js';
+import { TABLE_SCHEMAS, TABLE_SCORERS, listTracesArgsSchema, toTraceSpans, TABLE_WORKFLOW_SNAPSHOT } from './chunk-MNWW2R3U.js';
+import { deepEqual } from './chunk-T6PRRKMW.js';
 import { MastraError } from './chunk-FJEVLHJT.js';
 import { MastraBase } from './chunk-JIT2OY3X.js';
 
@@ -154,24 +154,33 @@ var AgentsStorage = class extends StorageDomain {
     if (!agent) {
       return null;
     }
+    let version = null;
     if (agent.activeVersionId) {
-      const activeVersion = await this.getVersion(agent.activeVersionId);
-      if (activeVersion) {
-        const {
-          id: _versionId,
-          agentId: _agentId,
-          versionNumber: _versionNumber,
-          changedFields: _changedFields,
-          changeMessage: _changeMessage,
-          createdAt: _createdAt,
-          ...snapshotConfig
-        } = activeVersion;
-        return {
-          ...agent,
-          ...snapshotConfig
-        };
+      version = await this.getVersion(agent.activeVersionId);
+      if (!version) {
+        console.warn(
+          `[AgentsStorage] Agent ${agent.id} has activeVersionId ${agent.activeVersionId} but version not found. Falling back to latest version.`
+        );
       }
     }
+    if (!version) {
+      version = await this.getLatestVersion(agent.id);
+    }
+    if (version) {
+      const {
+        id: _versionId,
+        agentId: _agentId,
+        versionNumber: _versionNumber,
+        changedFields: _changedFields,
+        changeMessage: _changeMessage,
+        createdAt: _createdAt,
+        ...snapshotConfig
+      } = version;
+      return {
+        ...agent,
+        ...snapshotConfig
+      };
+    }
     return agent;
   }
   /**
@@ -185,23 +194,27 @@ var AgentsStorage = class extends StorageDomain {
     const result = await this.listAgents(args);
     const resolvedAgents = await Promise.all(
       result.agents.map(async (agent) => {
+        let version = null;
         if (agent.activeVersionId) {
-          const activeVersion = await this.getVersion(agent.activeVersionId);
-          if (activeVersion) {
-            const {
-              id: _versionId,
-              agentId: _agentId,
-              versionNumber: _versionNumber,
-              changedFields: _changedFields,
-              changeMessage: _changeMessage,
-              createdAt: _createdAt,
-              ...snapshotConfig
-            } = activeVersion;
-            return {
-              ...agent,
-              ...snapshotConfig
-            };
-          }
+          version = await this.getVersion(agent.activeVersionId);
+        }
+        if (!version) {
+          version = await this.getLatestVersion(agent.id);
+        }
+        if (version) {
+          const {
+            id: _versionId,
+            agentId: _agentId,
+            versionNumber: _versionNumber,
+            changedFields: _changedFields,
+            changeMessage: _changeMessage,
+            createdAt: _createdAt,
+            ...snapshotConfig
+          } = version;
+          return {
+            ...agent,
+            ...snapshotConfig
+          };
         }
         return agent;
       })
@@ -279,10 +292,7 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       changedFields: Object.keys(snapshotConfig),
       changeMessage: "Initial version"
     });
-    newAgent.activeVersionId = versionId;
-    newAgent.status = "published";
-    this.db.agents.set(agent.id, newAgent);
-    return { ...newAgent };
+    return this.deepCopyAgent(newAgent);
   }
   async updateAgent({ id, ...updates }) {
     this.logger.debug(`InMemoryAgentsStorage: updateAgent called for ${id}`);
@@ -290,20 +300,69 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
     if (!existingAgent) {
       throw new Error(`Agent with id ${id} not found`);
     }
+    const { authorId, activeVersionId, metadata, ...configFields } = updates;
+    const configFieldNames = [
+      "name",
+      "description",
+      "instructions",
+      "model",
+      "tools",
+      "defaultOptions",
+      "workflows",
+      "agents",
+      "integrationTools",
+      "inputProcessors",
+      "outputProcessors",
+      "memory",
+      "scorers"
+    ];
+    const hasConfigUpdate = configFieldNames.some((field) => field in configFields);
     const updatedAgent = {
       ...existingAgent,
-      ...updates.authorId !== void 0 && { authorId: updates.authorId },
-      ...updates.activeVersionId !== void 0 && { activeVersionId: updates.activeVersionId },
-      ...updates.metadata !== void 0 && {
-        metadata: { ...existingAgent.metadata, ...updates.metadata }
+      ...authorId !== void 0 && { authorId },
+      ...activeVersionId !== void 0 && { activeVersionId },
+      ...metadata !== void 0 && {
+        metadata: { ...existingAgent.metadata, ...metadata }
       },
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (updates.activeVersionId !== void 0) {
+    if (activeVersionId !== void 0) {
       updatedAgent.status = "published";
     }
+    if (hasConfigUpdate) {
+      const latestVersion = await this.getLatestVersion(id);
+      if (!latestVersion) {
+        throw new Error(`No versions found for agent ${id}`);
+      }
+      const {
+        id: _versionId,
+        agentId: _agentId,
+        versionNumber: _versionNumber,
+        changedFields: _changedFields,
+        changeMessage: _changeMessage,
+        createdAt: _createdAt,
+        ...latestConfig
+      } = latestVersion;
+      const newConfig = {
+        ...latestConfig,
+        ...configFields
+      };
+      const changedFields = configFieldNames.filter(
+        (field) => field in configFields && configFields[field] !== latestConfig[field]
+      );
+      const newVersionId = crypto.randomUUID();
+      const newVersionNumber = latestVersion.versionNumber + 1;
+      await this.createVersion({
+        id: newVersionId,
+        agentId: id,
+        versionNumber: newVersionNumber,
+        ...newConfig,
+        changedFields,
+        changeMessage: `Updated ${changedFields.join(", ")}`
+      });
+    }
     this.db.agents.set(id, updatedAgent);
-    return { ...updatedAgent };
+    return this.deepCopyAgent(updatedAgent);
   }
   async deleteAgent({ id }) {
     this.logger.debug(`InMemoryAgentsStorage: deleteAgent called for ${id}`);
@@ -465,8 +524,8 @@ var InMemoryAgentsStorage = class extends AgentsStorage {
       workflows: version.workflows ? [...version.workflows] : version.workflows,
       agents: version.agents ? [...version.agents] : version.agents,
       integrationTools: version.integrationTools ? [...version.integrationTools] : version.integrationTools,
-      inputProcessors: version.inputProcessors ? version.inputProcessors.map((p) => ({ ...p })) : version.inputProcessors,
-      outputProcessors: version.outputProcessors ? version.outputProcessors.map((p) => ({ ...p })) : version.outputProcessors,
+      inputProcessors: version.inputProcessors ? [...version.inputProcessors] : version.inputProcessors,
+      outputProcessors: version.outputProcessors ? [...version.outputProcessors] : version.outputProcessors,
       memory: version.memory ? { ...version.memory } : version.memory,
       scorers: version.scorers ? { ...version.scorers } : version.scorers,
       changedFields: version.changedFields ? [...version.changedFields] : version.changedFields
@@ -505,6 +564,8 @@ var InMemoryDB = class {
   traces = /* @__PURE__ */ new Map();
   agents = /* @__PURE__ */ new Map();
   agentVersions = /* @__PURE__ */ new Map();
+  /** Observational memory records, keyed by resourceId, each holding array of records (generations) */
+  observationalMemory = /* @__PURE__ */ new Map();
   /**
    * Clears all data from all collections.
    * Useful for testing.
@@ -518,6 +579,7 @@ var InMemoryDB = class {
     this.traces.clear();
     this.agents.clear();
     this.agentVersions.clear();
+    this.observationalMemory.clear();
   }
 };
 
@@ -691,12 +753,30 @@ var SAFE_METADATA_KEY_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var MAX_METADATA_KEY_LENGTH = 128;
 var DISALLOWED_METADATA_KEYS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
 var MemoryStorage = class extends StorageDomain {
+  /**
+   * Whether this storage adapter supports Observational Memory.
+   * Adapters that implement OM methods should set this to true.
+   * Defaults to false for backwards compatibility with custom adapters.
+   */
+  supportsObservationalMemory = false;
   constructor() {
     super({
       component: "STORAGE",
       name: "MEMORY"
     });
   }
+  /**
+   * List messages by resource ID only (across all threads).
+   * Used by Observational Memory and LongMemEval for resource-scoped queries.
+   *
+   * @param args - Resource ID and pagination/filtering options
+   * @returns Paginated list of messages for the resource
+   */
+  async listMessagesByResourceId(_args) {
+    throw new Error(
+      `Resource-scoped message listing is not implemented by this storage adapter (${this.constructor.name}). Use an adapter that supports Observational Memory (pg, libsql, mongodb) or disable observational memory.`
+    );
+  }
   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.`
@@ -735,6 +815,122 @@ var MemoryStorage = class extends StorageDomain {
       direction: orderBy?.direction && orderBy.direction in THREAD_THREAD_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
     };
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  /**
+   * Get the current observational memory record for a thread/resource.
+   * Returns the most recent active record.
+   */
+  async getObservationalMemory(_threadId, _resourceId) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Get observational memory history (previous generations).
+   * Returns records in reverse chronological order (newest first).
+   */
+  async getObservationalMemoryHistory(_threadId, _resourceId, _limit) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Create a new observational memory record.
+   * Called when starting observations for a new thread/resource.
+   */
+  async initializeObservationalMemory(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Update active observations.
+   * Called when observations are created and immediately activated (no buffering).
+   */
+  async updateActiveObservations(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  // ============================================
+  // Buffering Methods (DISABLED - not currently used)
+  // These methods were designed for async observation buffering
+  // which has been disabled. Keeping commented for future reference.
+  // ============================================
+  // /**
+  //  * Update buffered observations.
+  //  * Called when observations are created asynchronously.
+  //  */
+  // async updateBufferedObservations(_input: UpdateBufferedObservationsInput): Promise<void> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  // /**
+  //  * Swap buffered observations to active.
+  //  * Atomic operation that:
+  //  * 1. Moves bufferedObservations → activeObservations
+  //  * 2. Moves bufferedMessageIds → observedMessageIds
+  //  * 3. Clears buffered state
+  //  */
+  // async swapBufferedToActive(_id: string): Promise<void> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  // /**
+  //  * Mark messages as currently being observed (in-flight).
+  //  */
+  // async markMessagesAsBuffering(_id: string, _messageIds: string[]): Promise<void> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  // /**
+  //  * Mark messages as buffered (observation complete but not active).
+  //  * Moves messageIds from bufferingMessageIds → bufferedMessageIds.
+  //  */
+  // async markMessagesAsBuffered(_id: string, _messageIds: string[]): Promise<void> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  /**
+   * Create a new generation from a reflection.
+   * Creates a new record with:
+   * - originType: 'reflection'
+   * - activeObservations containing the reflection
+   * - generationCount incremented from the current record
+   */
+  async createReflectionGeneration(_input) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  // /**
+  //  * Update buffered reflection (async reflection in progress).
+  //  */
+  // async updateBufferedReflection(_id: string, _reflection: string): Promise<void> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  // /**
+  //  * Swap buffered reflection to active observations.
+  //  * Creates a new generation and makes it the active one.
+  //  */
+  // async swapReflectionToActive(_id: string): Promise<ObservationalMemoryRecord> {
+  //   throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  // }
+  /**
+   * Set the isReflecting flag.
+   */
+  async setReflectingFlag(_id, _isReflecting) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Set the isObserving flag.
+   */
+  async setObservingFlag(_id, _isObserving) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Clear all observational memory for a thread/resource.
+   * Removes all records and history.
+   */
+  async clearObservationalMemory(_threadId, _resourceId) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
+  /**
+   * Add to the pending message token count.
+   * Called when messages are processed but observation hasn't triggered yet.
+   * This allows accumulating tokens across multiple sessions.
+   */
+  async addPendingMessageTokens(_id, _tokenCount) {
+    throw new Error(`Observational memory is not implemented by this storage adapter (${this.constructor.name}).`);
+  }
   /**
    * Validates metadata keys to prevent SQL injection attacks and prototype pollution.
    * Keys must start with a letter or underscore, followed by alphanumeric characters or underscores.
@@ -823,6 +1019,7 @@ var THREAD_THREAD_SORT_DIRECTION_SET = {
 
 // src/storage/domains/memory/inmemory.ts
 var InMemoryMemory = class extends MemoryStorage {
+  supportsObservationalMemory = true;
   db;
   constructor({ db }) {
     super();
@@ -832,6 +1029,7 @@ var InMemoryMemory = class extends MemoryStorage {
     this.db.threads.clear();
     this.db.messages.clear();
     this.db.resources.clear();
+    this.db.observationalMemory.clear();
   }
   async getThreadById({ threadId }) {
     this.logger.debug(`InMemoryMemory: getThreadById called for ${threadId}`);
@@ -872,7 +1070,7 @@ var InMemoryMemory = class extends MemoryStorage {
   }
   async listMessages({
     threadId,
-    resourceId,
+    resourceId: optionalResourceId,
     include,
     filter,
     perPage: perPageInput,
@@ -896,8 +1094,8 @@ var InMemoryMemory = class extends MemoryStorage {
     }
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     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;
+      if (threadIdSet && !threadIdSet.has(msg.thread_id)) return false;
+      if (optionalResourceId && msg.resourceId !== optionalResourceId) return false;
       return true;
     });
     threadMessages = filterByDateRange(threadMessages, (msg) => new Date(msg.createdAt), filter?.dateRange);
@@ -1014,6 +1212,50 @@ var InMemoryMemory = class extends MemoryStorage {
       hasMore
     };
   }
+  async listMessagesByResourceId({
+    resourceId,
+    filter,
+    perPage: perPageInput,
+    page = 0,
+    orderBy
+  }) {
+    this.logger.debug(`InMemoryMemory: listMessagesByResourceId called for resource ${resourceId}`);
+    const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+    const perPage = normalizePerPage(perPageInput, 40);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    let messages = Array.from(this.db.messages.values()).filter((msg) => msg.resourceId === resourceId);
+    messages = filterByDateRange(messages, (msg) => new Date(msg.createdAt), filter?.dateRange);
+    messages.sort((a, b) => {
+      const isDateField = field === "createdAt" || field === "updatedAt";
+      const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+      const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+      if (typeof aValue === "number" && typeof bValue === "number") {
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      }
+      return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+    });
+    const total = messages.length;
+    const paginatedMessages = messages.slice(offset, offset + perPage);
+    const list = new MessageList().add(
+      paginatedMessages.map((m) => this.parseStoredMessage(m)),
+      "memory"
+    );
+    const hasMore = offset + paginatedMessages.length < total;
+    return {
+      messages: list.get.all.db(),
+      total,
+      page,
+      perPage: perPageForResponse,
+      hasMore
+    };
+  }
   parseStoredMessage(message) {
     const { resourceId, content, role, thread_id, ...rest } = message;
     let parsedContent = safelyParseJSON(content);
@@ -1322,6 +1564,219 @@ var InMemoryMemory = class extends MemoryStorage {
       return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
     });
   }
+  // ============================================
+  // Observational Memory Implementation
+  // ============================================
+  getObservationalMemoryKey(threadId, resourceId) {
+    if (threadId) {
+      return `thread:${threadId}`;
+    }
+    return `resource:${resourceId}`;
+  }
+  async getObservationalMemory(threadId, resourceId) {
+    const key = this.getObservationalMemoryKey(threadId, resourceId);
+    const records = this.db.observationalMemory.get(key);
+    return records?.[0] ?? null;
+  }
+  async getObservationalMemoryHistory(threadId, resourceId, limit) {
+    const key = this.getObservationalMemoryKey(threadId, resourceId);
+    const records = this.db.observationalMemory.get(key) ?? [];
+    return limit != null ? records.slice(0, limit) : records;
+  }
+  async initializeObservationalMemory(input) {
+    const { threadId, resourceId, scope, config, observedTimezone } = input;
+    const key = this.getObservationalMemoryKey(threadId, resourceId);
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: crypto.randomUUID(),
+      scope,
+      threadId,
+      resourceId,
+      // Timestamps at top level
+      createdAt: now,
+      updatedAt: now,
+      // lastObservedAt starts undefined - all messages are "unobserved" initially
+      // This ensures historical data (like LongMemEval fixtures) works correctly
+      lastObservedAt: void 0,
+      originType: "initial",
+      generationCount: 0,
+      activeObservations: "",
+      // Buffering (for async observation/reflection)
+      bufferedObservations: void 0,
+      bufferedReflection: void 0,
+      // Message tracking
+      // Note: Message ID tracking removed in favor of cursor-based lastObservedAt
+      // Token tracking
+      totalTokensObserved: 0,
+      observationTokenCount: 0,
+      pendingMessageTokens: 0,
+      // State flags
+      isReflecting: false,
+      isObserving: false,
+      // Configuration
+      config,
+      // Timezone used for observation date formatting
+      observedTimezone,
+      // Extensible metadata (optional)
+      metadata: {}
+    };
+    const existing = this.db.observationalMemory.get(key) ?? [];
+    this.db.observationalMemory.set(key, [record, ...existing]);
+    return record;
+  }
+  async updateActiveObservations(input) {
+    const { id, observations, tokenCount, lastObservedAt, observedMessageIds } = input;
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.activeObservations = observations;
+    record.observationTokenCount = tokenCount;
+    record.totalTokensObserved += tokenCount;
+    record.pendingMessageTokens = 0;
+    record.lastObservedAt = lastObservedAt;
+    record.updatedAt = /* @__PURE__ */ new Date();
+    if (observedMessageIds) {
+      record.observedMessageIds = observedMessageIds;
+    }
+  }
+  async updateBufferedObservations(input) {
+    const { id, observations } = input;
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.bufferedObservations = observations;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async swapBufferedToActive(id) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    if (!record.bufferedObservations) {
+      return;
+    }
+    if (record.activeObservations) {
+      record.activeObservations = `${record.activeObservations}
+
+${record.bufferedObservations}`;
+    } else {
+      record.activeObservations = record.bufferedObservations;
+    }
+    record.bufferedObservations = void 0;
+    record.lastObservedAt = /* @__PURE__ */ new Date();
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async markMessagesAsBuffering(id, _messageIds) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async markMessagesAsBuffered(id, _messageIds) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async createReflectionGeneration(input) {
+    const { currentRecord, reflection, tokenCount } = input;
+    const key = this.getObservationalMemoryKey(currentRecord.threadId, currentRecord.resourceId);
+    const now = /* @__PURE__ */ new Date();
+    const newRecord = {
+      id: crypto.randomUUID(),
+      scope: currentRecord.scope,
+      threadId: currentRecord.threadId,
+      resourceId: currentRecord.resourceId,
+      // Timestamps at top level
+      createdAt: now,
+      updatedAt: now,
+      lastObservedAt: currentRecord.lastObservedAt ?? now,
+      // Carry over from observation (which always runs before reflection)
+      originType: "reflection",
+      generationCount: currentRecord.generationCount + 1,
+      activeObservations: reflection,
+      config: currentRecord.config,
+      totalTokensObserved: currentRecord.totalTokensObserved,
+      observationTokenCount: tokenCount,
+      pendingMessageTokens: 0,
+      isReflecting: false,
+      isObserving: false,
+      // Timezone used for observation date formatting
+      observedTimezone: currentRecord.observedTimezone,
+      // Extensible metadata (optional)
+      metadata: {}
+    };
+    const existing = this.db.observationalMemory.get(key) ?? [];
+    this.db.observationalMemory.set(key, [newRecord, ...existing]);
+    return newRecord;
+  }
+  async updateBufferedReflection(id, reflection) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.bufferedReflection = reflection;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async swapReflectionToActive(id) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    if (!record.bufferedReflection) {
+      throw new Error("No buffered reflection to swap");
+    }
+    const newRecord = await this.createReflectionGeneration({
+      currentRecord: record,
+      reflection: record.bufferedReflection,
+      tokenCount: 0
+      // Will be calculated by caller
+    });
+    record.bufferedReflection = void 0;
+    return newRecord;
+  }
+  async setReflectingFlag(id, isReflecting) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.isReflecting = isReflecting;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async setObservingFlag(id, isObserving) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.isObserving = isObserving;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  async clearObservationalMemory(threadId, resourceId) {
+    const key = this.getObservationalMemoryKey(threadId, resourceId);
+    this.db.observationalMemory.delete(key);
+  }
+  async addPendingMessageTokens(id, tokenCount) {
+    const record = this.findObservationalMemoryRecordById(id);
+    if (!record) {
+      throw new Error(`Observational memory record not found: ${id}`);
+    }
+    record.pendingMessageTokens = (record.pendingMessageTokens ?? 0) + tokenCount;
+    record.updatedAt = /* @__PURE__ */ new Date();
+  }
+  /**
+   * Helper to find an observational memory record by ID across all keys
+   */
+  findObservationalMemoryRecordById(id) {
+    for (const records of this.db.observationalMemory.values()) {
+      const record = records.find((r) => r.id === id);
+      if (record) return record;
+    }
+    return null;
+  }
 };
 
 // src/storage/domains/observability/base.ts
@@ -2317,7 +2772,8 @@ var StoreOperationsInMemory = class extends StoreOperations {
       mastra_scorers: /* @__PURE__ */ new Map(),
       mastra_ai_spans: /* @__PURE__ */ new Map(),
       mastra_agents: /* @__PURE__ */ new Map(),
-      mastra_agent_versions: /* @__PURE__ */ new Map()
+      mastra_agent_versions: /* @__PURE__ */ new Map(),
+      mastra_observational_memory: /* @__PURE__ */ new Map()
     };
   }
   getDatabase() {
@@ -2383,5 +2839,5 @@ var StoreOperationsInMemory = class extends StoreOperations {
 };
 
 export { AgentsStorage, InMemoryAgentsStorage, InMemoryDB, InMemoryMemory, InMemoryStore, MastraCompositeStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, ScoresInMemory, ScoresStorage, StorageDomain, StoreOperations, StoreOperationsInMemory, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createPendingMarker, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, filterByDateRange, getDefaultValue, getSqlType, jsonValueEquals, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
-//# sourceMappingURL=chunk-OQPAOUDS.js.map
-//# sourceMappingURL=chunk-OQPAOUDS.js.map
+//# sourceMappingURL=chunk-ZODRDMZ7.js.map
+//# sourceMappingURL=chunk-ZODRDMZ7.js.map