@mastra/libsql 1.1.0 → 1.2.0

package/dist/index.js

@@ -2039,6 +2039,21 @@ Note: This migration may take some time for large tables.
 };
 
 // src/storage/domains/agents/index.ts
+var SNAPSHOT_FIELDS = [
+  "name",
+  "description",
+  "instructions",
+  "model",
+  "tools",
+  "defaultOptions",
+  "workflows",
+  "agents",
+  "integrationTools",
+  "inputProcessors",
+  "outputProcessors",
+  "memory",
+  "scorers"
+];
 var AgentsLibSQL = class extends AgentsStorage {
   #db;
   #client;
@@ -2164,6 +2179,16 @@ var AgentsLibSQL = class extends AgentsStorage {
   }
   parseJson(value, fieldName) {
     if (!value) return void 0;
+    if (value instanceof ArrayBuffer || value && value.constructor && value.constructor.name === "ArrayBuffer") {
+      try {
+        const decoder = new TextDecoder();
+        const jsonString = decoder.decode(value);
+        return JSON.parse(jsonString);
+      } catch (error) {
+        console.error(`Failed to parse ArrayBuffer for ${fieldName}:`, error);
+        return void 0;
+      }
+    }
     if (typeof value !== "string") return value;
     try {
       return JSON.parse(value);
@@ -2241,15 +2266,6 @@ var AgentsLibSQL = class extends AgentsStorage {
         changedFields: Object.keys(snapshotConfig),
         changeMessage: "Initial version"
       });
-      await this.#db.update({
-        tableName: TABLE_AGENTS,
-        keys: { id: agent.id },
-        data: {
-          activeVersionId: versionId,
-          status: "published",
-          updatedAt: /* @__PURE__ */ new Date()
-        }
-      });
       const created = await this.getAgentById({ id: agent.id });
       if (!created) {
         throw new MastraError({
@@ -2288,16 +2304,57 @@ var AgentsLibSQL = class extends AgentsStorage {
           details: { agentId: id }
         });
       }
+      const metadataFields = {
+        authorId: updates.authorId,
+        activeVersionId: updates.activeVersionId,
+        metadata: updates.metadata
+      };
+      const configFields = {};
+      for (const field of SNAPSHOT_FIELDS) {
+        if (updates[field] !== void 0) {
+          configFields[field] = updates[field];
+        }
+      }
+      if (Object.keys(configFields).length > 0) {
+        const latestVersion = await this.getLatestVersion(id);
+        const nextVersionNumber = latestVersion ? latestVersion.versionNumber + 1 : 1;
+        if (!latestVersion) {
+          throw new MastraError({
+            id: createStorageErrorId("LIBSQL", "UPDATE_AGENT", "NO_VERSION"),
+            domain: ErrorDomain.STORAGE,
+            category: ErrorCategory.USER,
+            text: `Cannot update config fields for agent ${id} - no versions exist`,
+            details: { id }
+          });
+        }
+        const latestSnapshot = {};
+        for (const field of SNAPSHOT_FIELDS) {
+          if (latestVersion[field] !== void 0) {
+            latestSnapshot[field] = latestVersion[field];
+          }
+        }
+        const versionInput = {
+          id: crypto.randomUUID(),
+          agentId: id,
+          versionNumber: nextVersionNumber,
+          ...latestSnapshot,
+          // Start from latest version
+          ...configFields,
+          // Apply updates
+          changedFields: Object.keys(configFields),
+          changeMessage: `Updated: ${Object.keys(configFields).join(", ")}`
+        };
+        await this.createVersion(versionInput);
+      }
       const data = {
         updatedAt: /* @__PURE__ */ new Date()
       };
-      if (updates.authorId !== void 0) data.authorId = updates.authorId;
-      if (updates.activeVersionId !== void 0) {
-        data.activeVersionId = updates.activeVersionId;
-        data.status = "published";
+      if (metadataFields.authorId !== void 0) data.authorId = metadataFields.authorId;
+      if (metadataFields.activeVersionId !== void 0) {
+        data.activeVersionId = metadataFields.activeVersionId;
       }
-      if (updates.metadata !== void 0) {
-        data.metadata = { ...existingAgent.metadata, ...updates.metadata };
+      if (metadataFields.metadata !== void 0) {
+        data.metadata = metadataFields.metadata;
       }
       if (Object.keys(data).length > 1) {
         await this.#db.update({
@@ -2404,6 +2461,88 @@ var AgentsLibSQL = class extends AgentsStorage {
       );
     }
   }
+  async listAgentsResolved(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_AGENTS_RESOLVED", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const total = await this.#db.selectTotalCount({ tableName: TABLE_AGENTS });
+      if (total === 0) {
+        return {
+          agents: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const agents = await this.#db.selectMany({
+        tableName: TABLE_AGENTS,
+        orderBy: `"${field}" ${direction}`,
+        limit: limitValue,
+        offset
+      });
+      const resolvedAgents = await Promise.all(
+        agents.map(async (agent) => {
+          let version = null;
+          if (agent.activeVersionId) {
+            version = await this.getVersion(agent.activeVersionId);
+          }
+          if (!version) {
+            version = await this.getLatestVersion(agent.id);
+          }
+          if (!version) {
+            return agent;
+          }
+          return {
+            ...agent,
+            name: version.name,
+            description: version.description,
+            instructions: version.instructions,
+            model: version.model,
+            tools: version.tools,
+            defaultOptions: version.defaultOptions,
+            workflows: version.workflows,
+            agents: version.agents,
+            integrationTools: version.integrationTools,
+            inputProcessors: version.inputProcessors,
+            outputProcessors: version.outputProcessors,
+            memory: version.memory,
+            scorers: version.scorers
+          };
+        })
+      );
+      return {
+        agents: resolvedAgents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_AGENTS_RESOLVED", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
   // ==========================================================================
   // Agent Version Methods
   // ==========================================================================
@@ -2683,7 +2822,9 @@ var AgentsLibSQL = class extends AgentsStorage {
     };
   }
 };
+var OM_TABLE = "mastra_observational_memory";
 var MemoryLibSQL = class extends MemoryStorage {
+  supportsObservationalMemory = true;
   #client;
   #db;
   constructor(config) {
@@ -2696,16 +2837,42 @@ var MemoryLibSQL = class extends MemoryStorage {
     await this.#db.createTable({ tableName: TABLE_THREADS, schema: TABLE_SCHEMAS[TABLE_THREADS] });
     await this.#db.createTable({ tableName: TABLE_MESSAGES, schema: TABLE_SCHEMAS[TABLE_MESSAGES] });
     await this.#db.createTable({ tableName: TABLE_RESOURCES, schema: TABLE_SCHEMAS[TABLE_RESOURCES] });
+    let omSchema;
+    try {
+      const { OBSERVATIONAL_MEMORY_TABLE_SCHEMA } = await import('@mastra/core/storage');
+      omSchema = OBSERVATIONAL_MEMORY_TABLE_SCHEMA?.[OM_TABLE];
+    } catch {
+    }
+    if (omSchema) {
+      await this.#db.createTable({
+        tableName: OM_TABLE,
+        schema: omSchema
+      });
+      await this.#db.alterTable({
+        tableName: OM_TABLE,
+        schema: omSchema,
+        ifNotExists: ["observedMessageIds", "observedTimezone"]
+      });
+    }
     await this.#db.alterTable({
       tableName: TABLE_MESSAGES,
       schema: TABLE_SCHEMAS[TABLE_MESSAGES],
       ifNotExists: ["resourceId"]
     });
+    if (omSchema) {
+      await this.#client.execute({
+        sql: `CREATE INDEX IF NOT EXISTS idx_om_lookup_key ON "${OM_TABLE}" ("lookupKey")`,
+        args: []
+      });
+    }
   }
   async dangerouslyClearAll() {
     await this.#db.deleteData({ tableName: TABLE_MESSAGES });
     await this.#db.deleteData({ tableName: TABLE_THREADS });
     await this.#db.deleteData({ tableName: TABLE_RESOURCES });
+    {
+      await this.#db.deleteData({ tableName: OM_TABLE });
+    }
   }
   parseRow(row) {
     let content = row.content;
@@ -2933,6 +3100,126 @@ var MemoryLibSQL = class extends MemoryStorage {
       };
     }
   }
+  async listMessagesByResourceId(args) {
+    const { resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    if (!resourceId || typeof resourceId !== "string" || resourceId.trim().length === 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_MESSAGES", "INVALID_QUERY"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { resourceId: resourceId ?? "" }
+        },
+        new Error("resourceId is required")
+      );
+    }
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_MESSAGES", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY "${field}" ${direction}`;
+      const conditions = [];
+      const queryParams = [];
+      conditions.push(`"resourceId" = ?`);
+      queryParams.push(resourceId);
+      if (filter?.dateRange?.start) {
+        const startOp = filter.dateRange.startExclusive ? ">" : ">=";
+        conditions.push(`"createdAt" ${startOp} ?`);
+        queryParams.push(
+          filter.dateRange.start instanceof Date ? filter.dateRange.start.toISOString() : filter.dateRange.start
+        );
+      }
+      if (filter?.dateRange?.end) {
+        const endOp = filter.dateRange.endExclusive ? "<" : "<=";
+        conditions.push(`"createdAt" ${endOp} ?`);
+        queryParams.push(
+          filter.dateRange.end instanceof Date ? filter.dateRange.end.toISOString() : filter.dateRange.end
+        );
+      }
+      const whereClause = `WHERE ${conditions.join(" AND ")}`;
+      const countResult = await this.#client.execute({
+        sql: `SELECT COUNT(*) as count FROM ${TABLE_MESSAGES} ${whereClause}`,
+        args: queryParams
+      });
+      const total = Number(countResult.rows?.[0]?.count ?? 0);
+      const limitValue = perPageInput === false ? total : perPage;
+      const dataResult = await this.#client.execute({
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${TABLE_MESSAGES} ${whereClause} ${orderByStatement} LIMIT ? OFFSET ?`,
+        args: [...queryParams, limitValue, offset]
+      });
+      const messages = (dataResult.rows || []).map((row) => this.parseRow(row));
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const messageIds = new Set(messages.map((m) => m.id));
+      if (include && include.length > 0) {
+        const includeMessages = await this._getIncludedMessages({ include });
+        if (includeMessages) {
+          for (const includeMsg of includeMessages) {
+            if (!messageIds.has(includeMsg.id)) {
+              messages.push(includeMsg);
+              messageIds.add(includeMsg.id);
+            }
+          }
+        }
+      }
+      const list = new MessageList().add(messages, "memory");
+      let finalMessages = list.get.all.db();
+      finalMessages = finalMessages.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 hasMore = perPageInput !== false && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "LIST_MESSAGES", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { resourceId }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
+    }
+  }
   async saveMessages({ messages }) {
     if (messages.length === 0) return { messages };
     try {
@@ -3590,6 +3877,377 @@ var MemoryLibSQL = class extends MemoryStorage {
       );
     }
   }
+  // ============================================
+  // Observational Memory Methods
+  // ============================================
+  getOMKey(threadId, resourceId) {
+    return threadId ? `thread:${threadId}` : `resource:${resourceId}`;
+  }
+  parseOMRow(row) {
+    return {
+      id: row.id,
+      scope: row.scope,
+      threadId: row.threadId || null,
+      resourceId: row.resourceId,
+      createdAt: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
+      lastObservedAt: row.lastObservedAt ? new Date(row.lastObservedAt) : void 0,
+      originType: row.originType || "initial",
+      generationCount: Number(row.generationCount || 0),
+      activeObservations: row.activeObservations || "",
+      bufferedObservations: row.activeObservationsPendingUpdate || void 0,
+      totalTokensObserved: Number(row.totalTokensObserved || 0),
+      observationTokenCount: Number(row.observationTokenCount || 0),
+      pendingMessageTokens: Number(row.pendingMessageTokens || 0),
+      isReflecting: Boolean(row.isReflecting),
+      isObserving: Boolean(row.isObserving),
+      config: row.config ? JSON.parse(row.config) : {},
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      observedMessageIds: row.observedMessageIds ? JSON.parse(row.observedMessageIds) : void 0,
+      observedTimezone: row.observedTimezone || void 0
+    };
+  }
+  async getObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const result = await this.#client.execute({
+        // Use generationCount DESC for reliable ordering (incremented for each new record)
+        sql: `SELECT * FROM "${OM_TABLE}" WHERE "lookupKey" = ? ORDER BY "generationCount" DESC LIMIT 1`,
+        args: [lookupKey]
+      });
+      if (!result.rows || result.rows.length === 0) return null;
+      return this.parseOMRow(result.rows[0]);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "GET_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async getObservationalMemoryHistory(threadId, resourceId, limit = 10) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      const result = await this.#client.execute({
+        // Use generationCount DESC for reliable ordering (incremented for each new record)
+        sql: `SELECT * FROM "${OM_TABLE}" WHERE "lookupKey" = ? ORDER BY "generationCount" DESC LIMIT ?`,
+        args: [lookupKey, limit]
+      });
+      if (!result.rows) return [];
+      return result.rows.map((row) => this.parseOMRow(row));
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "GET_OBSERVATIONAL_MEMORY_HISTORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId, limit }
+        },
+        error
+      );
+    }
+  }
+  async initializeObservationalMemory(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.threadId, input.resourceId);
+      const record = {
+        id,
+        scope: input.scope,
+        threadId: input.threadId,
+        resourceId: input.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: void 0,
+        originType: "initial",
+        generationCount: 0,
+        activeObservations: "",
+        totalTokensObserved: 0,
+        observationTokenCount: 0,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.config,
+        observedTimezone: input.observedTimezone
+      };
+      await this.#client.execute({
+        sql: `INSERT INTO "${OM_TABLE}" (
+          id, "lookupKey", scope, "resourceId", "threadId",
+          "activeObservations", "activeObservationsPendingUpdate",
+          "originType", config, "generationCount", "lastObservedAt", "lastReflectionAt",
+          "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
+          "isObserving", "isReflecting", "observedTimezone", "createdAt", "updatedAt"
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          id,
+          lookupKey,
+          input.scope,
+          input.resourceId,
+          input.threadId || null,
+          "",
+          null,
+          "initial",
+          JSON.stringify(input.config),
+          0,
+          null,
+          null,
+          0,
+          0,
+          0,
+          false,
+          false,
+          input.observedTimezone || null,
+          now.toISOString(),
+          now.toISOString()
+        ]
+      });
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "INITIALIZE_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId: input.threadId, resourceId: input.resourceId }
+        },
+        error
+      );
+    }
+  }
+  async updateActiveObservations(input) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const observedMessageIdsJson = input.observedMessageIds ? JSON.stringify(input.observedMessageIds) : null;
+      const result = await this.#client.execute({
+        sql: `UPDATE "${OM_TABLE}" SET
+          "activeObservations" = ?,
+          "lastObservedAt" = ?,
+          "pendingMessageTokens" = 0,
+          "observationTokenCount" = ?,
+          "totalTokensObserved" = "totalTokensObserved" + ?,
+          "observedMessageIds" = ?,
+          "updatedAt" = ?
+        WHERE id = ?`,
+        args: [
+          input.observations,
+          input.lastObservedAt.toISOString(),
+          input.tokenCount,
+          input.tokenCount,
+          observedMessageIdsJson,
+          now.toISOString(),
+          input.id
+        ]
+      });
+      if (result.rowsAffected === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "UPDATE_ACTIVE_OBSERVATIONS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${input.id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "UPDATE_ACTIVE_OBSERVATIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id: input.id }
+        },
+        error
+      );
+    }
+  }
+  async createReflectionGeneration(input) {
+    try {
+      const id = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
+      const lookupKey = this.getOMKey(input.currentRecord.threadId, input.currentRecord.resourceId);
+      const record = {
+        id,
+        scope: input.currentRecord.scope,
+        threadId: input.currentRecord.threadId,
+        resourceId: input.currentRecord.resourceId,
+        createdAt: now,
+        updatedAt: now,
+        lastObservedAt: input.currentRecord.lastObservedAt,
+        originType: "reflection",
+        generationCount: input.currentRecord.generationCount + 1,
+        activeObservations: input.reflection,
+        totalTokensObserved: input.currentRecord.totalTokensObserved,
+        observationTokenCount: input.tokenCount,
+        pendingMessageTokens: 0,
+        isReflecting: false,
+        isObserving: false,
+        config: input.currentRecord.config,
+        metadata: input.currentRecord.metadata,
+        observedTimezone: input.currentRecord.observedTimezone
+      };
+      await this.#client.execute({
+        sql: `INSERT INTO "${OM_TABLE}" (
+          id, "lookupKey", scope, "resourceId", "threadId",
+          "activeObservations", "activeObservationsPendingUpdate",
+          "originType", config, "generationCount", "lastObservedAt", "lastReflectionAt",
+          "pendingMessageTokens", "totalTokensObserved", "observationTokenCount",
+          "isObserving", "isReflecting", "observedTimezone", "createdAt", "updatedAt"
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          id,
+          lookupKey,
+          record.scope,
+          record.resourceId,
+          record.threadId || null,
+          input.reflection,
+          null,
+          "reflection",
+          JSON.stringify(record.config),
+          input.currentRecord.generationCount + 1,
+          record.lastObservedAt?.toISOString() || null,
+          now.toISOString(),
+          record.pendingMessageTokens,
+          record.totalTokensObserved,
+          record.observationTokenCount,
+          false,
+          false,
+          record.observedTimezone || null,
+          now.toISOString(),
+          now.toISOString()
+        ]
+      });
+      return record;
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "CREATE_REFLECTION_GENERATION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { currentRecordId: input.currentRecord.id }
+        },
+        error
+      );
+    }
+  }
+  async setReflectingFlag(id, isReflecting) {
+    try {
+      const result = await this.#client.execute({
+        sql: `UPDATE "${OM_TABLE}" SET "isReflecting" = ?, "updatedAt" = ? WHERE id = ?`,
+        args: [isReflecting, (/* @__PURE__ */ new Date()).toISOString(), id]
+      });
+      if (result.rowsAffected === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "SET_REFLECTING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "SET_REFLECTING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isReflecting }
+        },
+        error
+      );
+    }
+  }
+  async setObservingFlag(id, isObserving) {
+    try {
+      const result = await this.#client.execute({
+        sql: `UPDATE "${OM_TABLE}" SET "isObserving" = ?, "updatedAt" = ? WHERE id = ?`,
+        args: [isObserving, (/* @__PURE__ */ new Date()).toISOString(), id]
+      });
+      if (result.rowsAffected === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "SET_OBSERVING_FLAG", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "SET_OBSERVING_FLAG", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, isObserving }
+        },
+        error
+      );
+    }
+  }
+  async clearObservationalMemory(threadId, resourceId) {
+    try {
+      const lookupKey = this.getOMKey(threadId, resourceId);
+      await this.#client.execute({
+        sql: `DELETE FROM "${OM_TABLE}" WHERE "lookupKey" = ?`,
+        args: [lookupKey]
+      });
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "CLEAR_OBSERVATIONAL_MEMORY", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { threadId, resourceId }
+        },
+        error
+      );
+    }
+  }
+  async addPendingMessageTokens(id, tokenCount) {
+    try {
+      const result = await this.#client.execute({
+        sql: `UPDATE "${OM_TABLE}" SET 
+          "pendingMessageTokens" = "pendingMessageTokens" + ?, 
+          "updatedAt" = ? 
+        WHERE id = ?`,
+        args: [tokenCount, (/* @__PURE__ */ new Date()).toISOString(), id]
+      });
+      if (result.rowsAffected === 0) {
+        throw new MastraError({
+          id: createStorageErrorId("LIBSQL", "ADD_PENDING_MESSAGE_TOKENS", "NOT_FOUND"),
+          text: `Observational memory record not found: ${id}`,
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        });
+      }
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("LIBSQL", "ADD_PENDING_MESSAGE_TOKENS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { id, tokenCount }
+        },
+        error
+      );
+    }
+  }
 };
 var ObservabilityLibSQL = class extends ObservabilityStorage {
   #db;