@mastra/libsql 0.10.4-alpha.1 → 0.11.0-alpha.3

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/libsql@0.10.4-alpha.1 build /home/runner/work/mastra/mastra/stores/libsql
+> @mastra/libsql@0.11.0-alpha.3 build /home/runner/work/mastra/mastra/stores/libsql
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 9194ms
+TSC ⚡️ Build success in 12207ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 10861ms
+DTS ⚡️ Build success in 13745ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 69.60 KB
-ESM ⚡️ Build success in 1544ms
-CJS dist/index.cjs 70.57 KB
-CJS ⚡️ Build success in 1547ms
+ESM dist/index.js 72.42 KB
+ESM ⚡️ Build success in 2002ms
+CJS dist/index.cjs 73.39 KB
+CJS ⚡️ Build success in 2005ms

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @mastra/libsql
 
+## 0.11.0-alpha.3
+
+### Minor Changes
+
+- 8a3bfd2: Update peerdeps to latest core
+
+### Patch Changes
+
+- Updated dependencies [792c4c0]
+- Updated dependencies [502fe05]
+- Updated dependencies [4efcfa0]
+  - @mastra/core@0.10.7-alpha.3
+
+## 0.10.4-alpha.2
+
+### Patch Changes
+
+- 15e9d26: Added per-resource working memory for LibSQL, Upstash, and PG
+- 0fb9d64: [MASTRA-4018] Update saveMessages in storage adapters to upsert messages
+- 144eb0b: [MASTRA-3669] Metadata Filter Types
+- f0150c4: Fix LibSQLStore and PgStore getMessagesPaginated implementation
+- Updated dependencies [15e9d26]
+- Updated dependencies [07d6d88]
+- Updated dependencies [5d74aab]
+- Updated dependencies [144eb0b]
+  - @mastra/core@0.10.7-alpha.2
+
 ## 0.10.4-alpha.1
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -12,22 +12,25 @@ import type { MastraMessageV2 } from '@mastra/core/agent';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRuns } from '@mastra/core/storage';
 
-export declare function buildFilterQuery(filter: VectorFilter): FilterResult;
+export declare function buildFilterQuery(filter: LibSQLVectorFilter): FilterResult;
 
 declare interface FilterResult {
     sql: string;
@@ -70,13 +73,23 @@ export { LibSQLConfig as LibSQLConfig_alias_1 }
  * - Can take either a single condition or an array of conditions
  *
  */
-export declare class LibSQLFilterTranslator extends BaseFilterTranslator {
+export declare class LibSQLFilterTranslator extends BaseFilterTranslator<LibSQLVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: LibSQLVectorFilter): LibSQLVectorFilter;
     private translateNode;
 }
 
-declare interface LibSQLQueryVectorParams extends QueryVectorParams {
+declare type LibSQLOperatorValueMap = Omit<OperatorValueMap, '$regex' | '$options' | '$in' | '$all' | '$nin' | '$eq' | '$ne'> & {
+    $size: number;
+    $contains: VectorFieldValue | Record<string, unknown>;
+    $all: VectorFieldValue;
+    $in: VectorFieldValue;
+    $nin: VectorFieldValue;
+    $eq: VectorFieldValue;
+    $ne: VectorFieldValue;
+};
+
+declare interface LibSQLQueryVectorParams extends QueryVectorParams<LibSQLVectorFilter> {
     minScore?: number;
 }
 
@@ -87,6 +100,7 @@ declare class LibSQLStore extends MastraStorage {
     constructor(config: LibSQLConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
     };
     private getCreateTableSQL;
     createTable({ tableName, schema, }: {
@@ -224,6 +238,17 @@ declare class LibSQLStore extends MastraStorage {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
     private hasColumn;
     private parseWorkflowRun;
 }
@@ -232,13 +257,13 @@ export { LibSQLStore as DefaultStorage_alias_1 }
 export { LibSQLStore }
 export { LibSQLStore as LibSQLStore_alias_1 }
 
-declare class LibSQLVector extends MastraVector {
+declare class LibSQLVector extends MastraVector<LibSQLVectorFilter> {
     private turso;
     private readonly maxRetries;
     private readonly initialBackoffMs;
     constructor({ connectionUrl, authToken, syncUrl, syncInterval, maxRetries, initialBackoffMs, }: LibSQLVectorConfig);
     private executeWriteOperationWithRetry;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: LibSQLVectorFilter): LibSQLVectorFilter;
     query({ indexName, queryVector, topK, filter, includeVector, minScore, }: LibSQLQueryVectorParams): Promise<QueryResult[]>;
     upsert(args: UpsertVectorParams): Promise<string[]>;
     private doUpsert;
@@ -302,4 +327,6 @@ declare interface LibSQLVectorConfig {
 export { LibSQLVectorConfig }
 export { LibSQLVectorConfig as LibSQLVectorConfig_alias_1 }
 
+export declare type LibSQLVectorFilter = VectorFilter<keyof LibSQLOperatorValueMap, LibSQLOperatorValueMap>;
+
 export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -12,22 +12,25 @@ import type { MastraMessageV2 } from '@mastra/core/agent';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRuns } from '@mastra/core/storage';
 
-export declare function buildFilterQuery(filter: VectorFilter): FilterResult;
+export declare function buildFilterQuery(filter: LibSQLVectorFilter): FilterResult;
 
 declare interface FilterResult {
     sql: string;
@@ -70,13 +73,23 @@ export { LibSQLConfig as LibSQLConfig_alias_1 }
  * - Can take either a single condition or an array of conditions
  *
  */
-export declare class LibSQLFilterTranslator extends BaseFilterTranslator {
+export declare class LibSQLFilterTranslator extends BaseFilterTranslator<LibSQLVectorFilter> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): VectorFilter;
+    translate(filter?: LibSQLVectorFilter): LibSQLVectorFilter;
     private translateNode;
 }
 
-declare interface LibSQLQueryVectorParams extends QueryVectorParams {
+declare type LibSQLOperatorValueMap = Omit<OperatorValueMap, '$regex' | '$options' | '$in' | '$all' | '$nin' | '$eq' | '$ne'> & {
+    $size: number;
+    $contains: VectorFieldValue | Record<string, unknown>;
+    $all: VectorFieldValue;
+    $in: VectorFieldValue;
+    $nin: VectorFieldValue;
+    $eq: VectorFieldValue;
+    $ne: VectorFieldValue;
+};
+
+declare interface LibSQLQueryVectorParams extends QueryVectorParams<LibSQLVectorFilter> {
     minScore?: number;
 }
 
@@ -87,6 +100,7 @@ declare class LibSQLStore extends MastraStorage {
     constructor(config: LibSQLConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
     };
     private getCreateTableSQL;
     createTable({ tableName, schema, }: {
@@ -224,6 +238,17 @@ declare class LibSQLStore extends MastraStorage {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
     private hasColumn;
     private parseWorkflowRun;
 }
@@ -232,13 +257,13 @@ export { LibSQLStore as DefaultStorage_alias_1 }
 export { LibSQLStore }
 export { LibSQLStore as LibSQLStore_alias_1 }
 
-declare class LibSQLVector extends MastraVector {
+declare class LibSQLVector extends MastraVector<LibSQLVectorFilter> {
     private turso;
     private readonly maxRetries;
     private readonly initialBackoffMs;
     constructor({ connectionUrl, authToken, syncUrl, syncInterval, maxRetries, initialBackoffMs, }: LibSQLVectorConfig);
     private executeWriteOperationWithRetry;
-    transformFilter(filter?: VectorFilter): VectorFilter;
+    transformFilter(filter?: LibSQLVectorFilter): LibSQLVectorFilter;
     query({ indexName, queryVector, topK, filter, includeVector, minScore, }: LibSQLQueryVectorParams): Promise<QueryResult[]>;
     upsert(args: UpsertVectorParams): Promise<string[]>;
     private doUpsert;
@@ -302,4 +327,6 @@ declare interface LibSQLVectorConfig {
 export { LibSQLVectorConfig }
 export { LibSQLVectorConfig as LibSQLVectorConfig_alias_1 }
 
+export declare type LibSQLVectorFilter = VectorFilter<keyof LibSQLOperatorValueMap, LibSQLOperatorValueMap>;
+
 export { }

package/dist/index.cjs

@@ -409,7 +409,7 @@ function buildCondition(key, value, parentPath) {
   return handleOperator(key, value);
 }
 function handleLogicalOperator(key, value, parentPath) {
-  if (!value || value.length === 0) {
+  if (!value || Array.isArray(value) && value.length === 0) {
     switch (key) {
       case "$and":
       case "$nor":
@@ -433,7 +433,7 @@ function handleLogicalOperator(key, value, parentPath) {
   const values = [];
   const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
   const conditions = Array.isArray(value) ? value.map((f) => {
-    const entries = Object.entries(f);
+    const entries = !!f ? Object.entries(f) : [];
     return entries.map(([k, v]) => buildCondition(k, v));
   }) : [buildCondition(key, value)];
   const joined = conditions.flat().map((c) => {
@@ -932,7 +932,8 @@ var LibSQLStore = class extends storage.MastraStorage {
   }
   get supports() {
     return {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   getCreateTableSQL(tableName, schema) {
@@ -1481,7 +1482,8 @@ var LibSQLStore = class extends storage.MastraStorage {
   }
   async getMessagesPaginated(args) {
     const { threadId, format, selectBy } = args;
-    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
     const messages = [];
@@ -1521,7 +1523,7 @@ var LibSQLStore = class extends storage.MastraStorage {
         args: queryParams
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -1530,9 +1532,11 @@ var LibSQLStore = class extends storage.MastraStorage {
           hasMore: false
         };
       }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
       const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", thread_id FROM ${storage.TABLE_MESSAGES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset]
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${storage.TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, ...excludeIds, perPage, currentOffset]
       });
       messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
       const messagesToReturn = format === "v1" ? new agent.MessageList().add(messages, "memory").get.all.v1() : new agent.MessageList().add(messages, "memory").get.all.v2();
@@ -1582,7 +1586,14 @@ var LibSQLStore = class extends storage.MastraStorage {
         }
         return {
           sql: `INSERT INTO ${storage.TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                  thread_id=excluded.thread_id,
+                  content=excluded.content,
+                  role=excluded.role,
+                  type=excluded.type,
+                  resourceId=excluded.resourceId
+              `,
           args: [
             message.id,
             message.threadId,
@@ -2008,6 +2019,75 @@ var LibSQLStore = class extends storage.MastraStorage {
       );
     }
   }
+  async getResourceById({ resourceId }) {
+    const result = await this.load({
+      tableName: storage.TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
+      workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+    };
+  }
+  async saveResource({ resource }) {
+    await this.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const updates = [];
+    const values = [];
+    if (workingMemory !== void 0) {
+      updates.push("workingMemory = ?");
+      values.push(workingMemory);
+    }
+    if (metadata) {
+      updates.push("metadata = ?");
+      values.push(JSON.stringify(updatedResource.metadata));
+    }
+    updates.push("updatedAt = ?");
+    values.push(updatedResource.updatedAt.toISOString());
+    values.push(resourceId);
+    await this.client.execute({
+      sql: `UPDATE ${storage.TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
+      args: values
+    });
+    return updatedResource;
+  }
   async hasColumn(table, column) {
     const result = await this.client.execute({
       sql: `PRAGMA table_info(${table})`

package/dist/index.js

@@ -4,7 +4,7 @@ import { parseSqlIdentifier, parseFieldKey } from '@mastra/core/utils';
 import { MastraVector } from '@mastra/core/vector';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import { MessageList } from '@mastra/core/agent';
-import { MastraStorage, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS, TABLE_MESSAGES, TABLE_EVALS, TABLE_TRACES } from '@mastra/core/storage';
+import { MastraStorage, TABLE_WORKFLOW_SNAPSHOT, TABLE_THREADS, TABLE_MESSAGES, TABLE_EVALS, TABLE_TRACES, TABLE_RESOURCES } from '@mastra/core/storage';
 
 // src/vector/index.ts
 var LibSQLFilterTranslator = class extends BaseFilterTranslator {
@@ -407,7 +407,7 @@ function buildCondition(key, value, parentPath) {
   return handleOperator(key, value);
 }
 function handleLogicalOperator(key, value, parentPath) {
-  if (!value || value.length === 0) {
+  if (!value || Array.isArray(value) && value.length === 0) {
     switch (key) {
       case "$and":
       case "$nor":
@@ -431,7 +431,7 @@ function handleLogicalOperator(key, value, parentPath) {
   const values = [];
   const joinOperator = key === "$or" || key === "$nor" ? "OR" : "AND";
   const conditions = Array.isArray(value) ? value.map((f) => {
-    const entries = Object.entries(f);
+    const entries = !!f ? Object.entries(f) : [];
     return entries.map(([k, v]) => buildCondition(k, v));
   }) : [buildCondition(key, value)];
   const joined = conditions.flat().map((c) => {
@@ -930,7 +930,8 @@ var LibSQLStore = class extends MastraStorage {
   }
   get supports() {
     return {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   getCreateTableSQL(tableName, schema) {
@@ -1479,7 +1480,8 @@ var LibSQLStore = class extends MastraStorage {
   }
   async getMessagesPaginated(args) {
     const { threadId, format, selectBy } = args;
-    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage = perPageInput !== void 0 ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
     const messages = [];
@@ -1519,7 +1521,7 @@ var LibSQLStore = class extends MastraStorage {
         args: queryParams
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -1528,9 +1530,11 @@ var LibSQLStore = class extends MastraStorage {
           hasMore: false
         };
       }
+      const excludeIds = messages.map((m) => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(", ");
       const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", thread_id FROM ${TABLE_MESSAGES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset]
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ""} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, ...excludeIds, perPage, currentOffset]
       });
       messages.push(...(dataResult.rows || []).map((row) => this.parseRow(row)));
       const messagesToReturn = format === "v1" ? new MessageList().add(messages, "memory").get.all.v1() : new MessageList().add(messages, "memory").get.all.v2();
@@ -1580,7 +1584,14 @@ var LibSQLStore = class extends MastraStorage {
         }
         return {
           sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                  thread_id=excluded.thread_id,
+                  content=excluded.content,
+                  role=excluded.role,
+                  type=excluded.type,
+                  resourceId=excluded.resourceId
+              `,
           args: [
             message.id,
             message.threadId,
@@ -2006,6 +2017,75 @@ var LibSQLStore = class extends MastraStorage {
       );
     }
   }
+  async getResourceById({ resourceId }) {
+    const result = await this.load({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId }
+    });
+    if (!result) {
+      return null;
+    }
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
+      workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
+    };
+  }
+  async saveResource({ resource }) {
+    await this.insert({
+      tableName: TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    const existingResource = await this.getResourceById({ resourceId });
+    if (!existingResource) {
+      const newResource = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      return this.saveResource({ resource: newResource });
+    }
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const updates = [];
+    const values = [];
+    if (workingMemory !== void 0) {
+      updates.push("workingMemory = ?");
+      values.push(workingMemory);
+    }
+    if (metadata) {
+      updates.push("metadata = ?");
+      values.push(JSON.stringify(updatedResource.metadata));
+    }
+    updates.push("updatedAt = ?");
+    values.push(updatedResource.updatedAt.toISOString());
+    values.push(resourceId);
+    await this.client.execute({
+      sql: `UPDATE ${TABLE_RESOURCES} SET ${updates.join(", ")} WHERE id = ?`,
+      args: values
+    });
+    return updatedResource;
+  }
   async hasColumn(table, column) {
     const result = await this.client.execute({
       sql: `PRAGMA table_info(${table})`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.4-alpha.1",
+  "version": "0.11.0-alpha.3",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -25,16 +25,16 @@
   "devDependencies": {
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
-    "eslint": "^9.28.0",
+    "eslint": "^9.29.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
+    "@internal/lint": "0.0.13",
     "@internal/storage-test-utils": "0.0.9",
-    "@mastra/core": "0.10.7-alpha.1",
-    "@internal/lint": "0.0.13"
+    "@mastra/core": "0.10.7-alpha.3"
   },
   "peerDependencies": {
-    "@mastra/core": ">=0.10.4-0 <0.11.0"
+    "@mastra/core": ">=0.10.7-0 <0.11.0-0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.ts

@@ -11,6 +11,7 @@ import {
   TABLE_MESSAGES,
   TABLE_THREADS,
   TABLE_TRACES,
+  TABLE_RESOURCES,
   TABLE_WORKFLOW_SNAPSHOT,
 } from '@mastra/core/storage';
 import type {
@@ -19,6 +20,7 @@ import type {
   PaginationInfo,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageResourceType,
   TABLE_NAMES,
   WorkflowRun,
   WorkflowRuns,
@@ -84,9 +86,11 @@ export class LibSQLStore extends MastraStorage {
 
   public get supports(): {
     selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
   } {
     return {
       selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
     };
   }
 
@@ -748,7 +752,9 @@ export class LibSQLStore extends MastraStorage {
     },
   ): Promise<PaginationInfo & { messages: MastraMessageV1[] | MastraMessageV2[] }> {
     const { threadId, format, selectBy } = args;
-    const { page = 0, perPage = 40, dateRange } = selectBy?.pagination || {};
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
+    const perPage =
+      perPageInput !== undefined ? perPageInput : this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
 
@@ -795,7 +801,7 @@ export class LibSQLStore extends MastraStorage {
       });
       const total = Number(countResult.rows?.[0]?.count ?? 0);
 
-      if (total === 0) {
+      if (total === 0 && messages.length === 0) {
         return {
           messages: [],
           total: 0,
@@ -805,9 +811,12 @@ export class LibSQLStore extends MastraStorage {
         };
       }
 
+      const excludeIds = messages.map(m => m.id);
+      const excludeIdsParam = excludeIds.map((_, idx) => `$${idx + queryParams.length + 1}`).join(', ');
+
       const dataResult = await this.client.execute({
-        sql: `SELECT id, content, role, type, "createdAt", thread_id FROM ${TABLE_MESSAGES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, perPage, currentOffset],
+        sql: `SELECT id, content, role, type, "createdAt", "resourceId", "thread_id" FROM ${TABLE_MESSAGES} ${whereClause} ${excludeIds.length ? `AND id NOT IN (${excludeIdsParam})` : ''} ORDER BY "createdAt" DESC LIMIT ? OFFSET ?`,
+        args: [...queryParams, ...excludeIds, perPage, currentOffset],
       });
 
       messages.push(...(dataResult.rows || []).map((row: any) => this.parseRow(row)));
@@ -871,7 +880,14 @@ export class LibSQLStore extends MastraStorage {
         }
         return {
           sql: `INSERT INTO ${TABLE_MESSAGES} (id, thread_id, content, role, type, createdAt, resourceId) 
-                VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(id) DO UPDATE SET
+                  thread_id=excluded.thread_id,
+                  content=excluded.content,
+                  role=excluded.role,
+                  type=excluded.type,
+                  resourceId=excluded.resourceId
+              `,
           args: [
             message.id,
             message.threadId!,
@@ -1416,6 +1432,96 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    const result = await this.load<StorageResourceType>({
+      tableName: TABLE_RESOURCES,
+      keys: { id: resourceId },
+    });
+
+    if (!result) {
+      return null;
+    }
+
+    return {
+      ...result,
+      // Ensure workingMemory is always returned as a string, even if auto-parsed as JSON
+      workingMemory:
+        typeof result.workingMemory === 'object' ? JSON.stringify(result.workingMemory) : result.workingMemory,
+      metadata: typeof result.metadata === 'string' ? JSON.parse(result.metadata) : result.metadata,
+    };
+  }
+
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    await this.insert({
+      tableName: TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+      },
+    });
+
+    return resource;
+  }
+
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    const existingResource = await this.getResourceById({ resourceId });
+
+    if (!existingResource) {
+      // Create new resource if it doesn't exist
+      const newResource: StorageResourceType = {
+        id: resourceId,
+        workingMemory,
+        metadata: metadata || {},
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      return this.saveResource({ resource: newResource });
+    }
+
+    const updatedResource = {
+      ...existingResource,
+      workingMemory: workingMemory !== undefined ? workingMemory : existingResource.workingMemory,
+      metadata: {
+        ...existingResource.metadata,
+        ...metadata,
+      },
+      updatedAt: new Date(),
+    };
+
+    const updates: string[] = [];
+    const values: InValue[] = [];
+
+    if (workingMemory !== undefined) {
+      updates.push('workingMemory = ?');
+      values.push(workingMemory);
+    }
+
+    if (metadata) {
+      updates.push('metadata = ?');
+      values.push(JSON.stringify(updatedResource.metadata));
+    }
+
+    updates.push('updatedAt = ?');
+    values.push(updatedResource.updatedAt.toISOString());
+
+    values.push(resourceId);
+
+    await this.client.execute({
+      sql: `UPDATE ${TABLE_RESOURCES} SET ${updates.join(', ')} WHERE id = ?`,
+      args: values,
+    });
+
+    return updatedResource;
+  }
+
   private async hasColumn(table: string, column: string): Promise<boolean> {
     const result = await this.client.execute({
       sql: `PRAGMA table_info(${table})`,

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
+import type { LibSQLVectorFilter } from './filter';
 import { LibSQLFilterTranslator } from './filter';
 
 describe('LibSQLFilterTranslator', () => {
@@ -17,14 +18,8 @@ describe('LibSQLFilterTranslator', () => {
       });
     });
 
-    it('translates array to $in', () => {
-      expect(translator.translate({ field: ['a', 'b'] })).toEqual({
-        field: { $in: ['a', 'b'] },
-      });
-    });
-
     it('preserves comparison operators', () => {
-      const filter = {
+      const filter: LibSQLVectorFilter = {
         field1: { $eq: 'value' },
         field2: { $ne: 'value' },
         field3: { $gt: 5 },
@@ -55,7 +50,7 @@ describe('LibSQLFilterTranslator', () => {
           nested: {
             field: 'value',
           },
-        }),
+        } as any),
       ).toEqual({
         'nested.field': { $eq: 'value' },
       });
@@ -65,7 +60,8 @@ describe('LibSQLFilterTranslator', () => {
   // Array Operations
   describe('array operations', () => {
     it('translates array to $in', () => {
-      expect(translator.translate({ field: ['a', 'b'] })).toEqual({
+      const filter: LibSQLVectorFilter = { field: ['a', 'b'] };
+      expect(translator.translate(filter)).toEqual({
         field: { $in: ['a', 'b'] },
       });
     });
@@ -82,7 +78,7 @@ describe('LibSQLFilterTranslator', () => {
     it('handles empty arrays', () => {
       expect(
         translator.translate({
-          field: [],
+          field: [] as any,
         }),
       ).toEqual({
         field: { $in: [] },
@@ -128,7 +124,7 @@ describe('LibSQLFilterTranslator', () => {
   });
 
   // Array Operator Normalization
-  describe('array operator normalization', () => {
+  describe('Array operator normalization', () => {
     it('normalizes single values for $all', () => {
       expect(
         translator.translate({
@@ -173,7 +169,7 @@ describe('LibSQLFilterTranslator', () => {
   // Logical Operators
   describe('Logical Operators', () => {
     it('handles logical operators', () => {
-      const filter = {
+      const filter: LibSQLVectorFilter = {
         $and: [{ field1: { $eq: 'value1' } }, { field2: { $eq: 'value2' } }],
         $or: [{ field3: { $eq: 'value3' } }, { field4: { $eq: 'value4' } }],
       };
@@ -457,16 +453,6 @@ describe('LibSQLFilterTranslator', () => {
         field: { $eq: '' },
       });
     });
-
-    it('handles empty arrays', () => {
-      expect(
-        translator.translate({
-          field: [],
-        }),
-      ).toEqual({
-        field: { $in: [] },
-      });
-    });
   });
 
   // Complex Filter Structures
@@ -540,53 +526,10 @@ describe('LibSQLFilterTranslator', () => {
     });
   });
 
-  // Array Operator Normalization
-  describe('Array Operator Normalization', () => {
-    it('normalizes single values for $all', () => {
-      expect(
-        translator.translate({
-          field: { $all: 'value' },
-        }),
-      ).toEqual({
-        field: { $all: ['value'] },
-      });
-    });
-
-    it('normalizes single values for $in', () => {
-      expect(
-        translator.translate({
-          field: { $in: 'value' },
-        }),
-      ).toEqual({
-        field: { $in: ['value'] },
-      });
-    });
-
-    it('normalizes single values for $nin', () => {
-      expect(
-        translator.translate({
-          field: { $nin: 'value' },
-        }),
-      ).toEqual({
-        field: { $nin: ['value'] },
-      });
-    });
-
-    it('preserves arrays for array operators', () => {
-      expect(
-        translator.translate({
-          field: { $all: ['value1', 'value2'] },
-        }),
-      ).toEqual({
-        field: { $all: ['value1', 'value2'] },
-      });
-    });
-  });
-
   // Operator Support Validation
   describe('Operator Support Validation', () => {
     it('ensure all operator filters are supported', () => {
-      const supportedFilters = [
+      const supportedFilters: LibSQLVectorFilter[] = [
         // Basic comparison operators
         { field: { $eq: 'value' } },
         { field: { $ne: 'value' } },
@@ -612,12 +555,7 @@ describe('LibSQLFilterTranslator', () => {
         { $or: [{ field1: 'value1' }, { field2: 'value2' }] },
         { $nor: [{ field1: 'value1' }, { field2: 'value2' }] },
 
-        { $and: { field: 'value' } },
-        { $or: { field: 'value' } },
-        { $nor: { field: 'value' } },
-        { $not: { field: 'value' } },
-
-        { $or: [{ $and: { field1: 'value1' } }, { $not: { field2: 'value2' } }] },
+        { $or: [{ $and: [{ field1: 'value1' }] }, { $not: { field2: 'value2' } }] },
 
         { field: { $not: { $eq: 'value' } } },
         { field: { $not: { $in: ['value1', 'value2'] } } },
@@ -634,7 +572,7 @@ describe('LibSQLFilterTranslator', () => {
 
     it('throws error for $not if not an object', () => {
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: [{ field: 'value' }] })).toThrow();
+      expect(() => translator.translate({ $not: [{ field: 'value' }] } as any)).toThrow();
     });
     it('throws error for $not if empty', () => {
       expect(() => translator.translate({ $not: {} })).toThrow();
@@ -646,21 +584,21 @@ describe('LibSQLFilterTranslator', () => {
       expect(() =>
         translator.translate({
           field: { $and: [{ $eq: 'value1' }, { $eq: 'value2' }] },
-        }),
+        } as any),
       ).toThrow();
 
       // $or cannot be used in field conditions
       expect(() =>
         translator.translate({
           field: { $or: [{ $eq: 'value1' }, { $eq: 'value2' }] },
-        }),
+        } as any),
       ).toThrow();
 
       // $nor cannot be used in field conditions
       expect(() =>
         translator.translate({
           field: { $nor: [{ $eq: 'value1' }, { $eq: 'value2' }] },
-        }),
+        } as any),
       ).toThrow();
     });
 
@@ -709,7 +647,7 @@ describe('LibSQLFilterTranslator', () => {
           field: {
             $gt: {
               $or: [{ subfield: 'value1' }, { subfield: 'value2' }],
-            },
+            } as any,
           },
         }),
       ).toThrow();
@@ -723,17 +661,17 @@ describe('LibSQLFilterTranslator', () => {
                 $and: [{ subfield: 'value1' }, { subfield: 'value2' }],
               },
             ],
-          },
+          } as any,
         }),
       ).toThrow();
     });
 
     it('validates $not operator structure', () => {
       // $not must be an object
-      expect(() => translator.translate({ field: { $not: 'value' } })).toThrow();
+      expect(() => translator.translate({ field: { $not: 'value' } } as any)).toThrow();
       expect(() => translator.translate({ field: { $not: ['value'] } })).toThrow();
       expect(() => translator.translate({ $not: 'value' })).toThrow();
-      expect(() => translator.translate({ $not: ['value'] })).toThrow();
+      expect(() => translator.translate({ $not: ['value'] } as any)).toThrow();
     });
 
     it('validates $not operator nesting', () => {
@@ -793,7 +731,7 @@ describe('LibSQLFilterTranslator', () => {
       const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
-        expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);
+        expect(() => translator.translate(filter as any)).toThrow(/Invalid top-level operator/);
       });
     });
     it('allows logical operators at top level', () => {
@@ -815,13 +753,13 @@ describe('LibSQLFilterTranslator', () => {
       // Should throw for non-object values
       expect(() =>
         translator.translate({
-          field: { $elemMatch: 'value' },
+          field: { $elemMatch: 'value' } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
 
       expect(() =>
         translator.translate({
-          field: { $elemMatch: ['value'] },
+          field: { $elemMatch: ['value'] } as any,
         }),
       ).toThrow('$elemMatch requires an object with conditions');
     });
@@ -962,7 +900,7 @@ describe('LibSQLFilterTranslator', () => {
   // Unsupported Operations
   describe('unsupported operators', () => {
     it('throws on unsupported operators', () => {
-      expect(() => translator.translate({ field: { $regex: 'value' } })).toThrow();
+      expect(() => translator.translate({ field: { $regex: 'value' } } as any)).toThrow();
     });
   });
 });

package/src/vector/filter.ts

@@ -1,5 +1,19 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, VectorFilter, OperatorSupport } from '@mastra/core/vector/filter';
+import type { VectorFilter, OperatorSupport, OperatorValueMap, VectorFieldValue } from '@mastra/core/vector/filter';
+
+type LibSQLOperatorValueMap = Omit<
+  OperatorValueMap,
+  '$regex' | '$options' | '$in' | '$all' | '$nin' | '$eq' | '$ne'
+> & {
+  $size: number;
+  $contains: VectorFieldValue | Record<string, unknown>;
+  $all: VectorFieldValue;
+  $in: VectorFieldValue;
+  $nin: VectorFieldValue;
+  $eq: VectorFieldValue;
+  $ne: VectorFieldValue;
+};
+export type LibSQLVectorFilter = VectorFilter<keyof LibSQLOperatorValueMap, LibSQLOperatorValueMap>;
 
 /**
  * Translates MongoDB-style filters to LibSQL compatible filters.
@@ -11,7 +25,7 @@ import type { FieldCondition, VectorFilter, OperatorSupport } from '@mastra/core
  * - Can take either a single condition or an array of conditions
  *
  */
-export class LibSQLFilterTranslator extends BaseFilterTranslator {
+export class LibSQLFilterTranslator extends BaseFilterTranslator<LibSQLVectorFilter> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -20,7 +34,7 @@ export class LibSQLFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): VectorFilter {
+  translate(filter?: LibSQLVectorFilter): LibSQLVectorFilter {
     if (this.isEmpty(filter)) {
       return filter;
     }
@@ -28,7 +42,7 @@ export class LibSQLFilterTranslator extends BaseFilterTranslator {
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, currentPath: string = ''): any {
+  private translateNode(node: LibSQLVectorFilter, currentPath: string = ''): any {
     if (this.isRegex(node)) {
       throw new Error('Direct regex pattern format is not supported in LibSQL');
     }
@@ -74,7 +88,7 @@ export class LibSQLFilterTranslator extends BaseFilterTranslator {
 
       if (this.isLogicalOperator(key)) {
         result[key] = Array.isArray(value)
-          ? value.map((filter: VectorFilter) => this.translateNode(filter))
+          ? value.map((filter: LibSQLVectorFilter) => this.translateNode(filter))
           : this.translateNode(value);
       } else if (this.isOperator(key)) {
         if (this.isArrayOperator(key) && !Array.isArray(value) && key !== '$elemMatch') {

package/src/vector/index.test.ts

@@ -1130,7 +1130,7 @@ describe('LibSQLVector', () => {
           vectorDB.query({
             indexName,
             queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
+            filter: { price: { $invalid: 100 } } as any,
           }),
         ).rejects.toThrow('Unsupported operator: $invalid');
       });
@@ -1360,16 +1360,6 @@ describe('LibSQLVector', () => {
         });
       });
 
-      it('should throw error for invalid operator', async () => {
-        await expect(
-          vectorDB.query({
-            indexName,
-            queryVector: [1, 0, 0],
-            filter: { price: { $invalid: 100 } },
-          }),
-        ).rejects.toThrow('Unsupported operator: $invalid');
-      });
-
       it('should handle multiple logical operators at root level', async () => {
         const results = await vectorDB.query({
           indexName,

package/src/vector/index.ts

@@ -15,11 +15,11 @@ import type {
   DeleteVectorParams,
   UpdateVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
+import type { LibSQLVectorFilter } from './filter';
 import { LibSQLFilterTranslator } from './filter';
 import { buildFilterQuery } from './sql-builder';
 
-interface LibSQLQueryVectorParams extends QueryVectorParams {
+interface LibSQLQueryVectorParams extends QueryVectorParams<LibSQLVectorFilter> {
   minScore?: number;
 }
 
@@ -41,7 +41,7 @@ export interface LibSQLVectorConfig {
   initialBackoffMs?: number;
 }
 
-export class LibSQLVector extends MastraVector {
+export class LibSQLVector extends MastraVector<LibSQLVectorFilter> {
   private turso: TursoClient;
   private readonly maxRetries: number;
   private readonly initialBackoffMs: number;
@@ -109,7 +109,7 @@ export class LibSQLVector extends MastraVector {
     throw new Error('LibSQLVector: Max retries reached, but no error was re-thrown from the loop.');
   }
 
-  transformFilter(filter?: VectorFilter) {
+  transformFilter(filter?: LibSQLVectorFilter) {
     const translator = new LibSQLFilterTranslator();
     return translator.translate(filter);
   }

package/src/vector/sql-builder.ts

@@ -6,8 +6,8 @@ import type {
   ArrayOperator,
   ElementOperator,
   LogicalOperator,
-  VectorFilter,
 } from '@mastra/core/vector/filter';
+import type { LibSQLVectorFilter } from './filter';
 
 type OperatorType =
   | BasicOperator
@@ -372,7 +372,7 @@ function escapeLikePattern(str: string): string {
   return str.replace(/([%_\\])/g, '\\$1');
 }
 
-export function buildFilterQuery(filter: VectorFilter): FilterResult {
+export function buildFilterQuery(filter: LibSQLVectorFilter): FilterResult {
   if (!filter) {
     return { sql: '', values: [] };
   }
@@ -428,11 +428,11 @@ function buildCondition(key: string, value: any, parentPath: string): FilterResu
 
 function handleLogicalOperator(
   key: '$and' | '$or' | '$not' | '$nor',
-  value: VectorFilter[] | VectorFilter,
+  value: LibSQLVectorFilter[] | LibSQLVectorFilter,
   parentPath: string,
 ): FilterResult {
   // Handle empty conditions
-  if (!value || value.length === 0) {
+  if (!value || (Array.isArray(value) && value.length === 0)) {
     switch (key) {
       case '$and':
       case '$nor':
@@ -460,7 +460,7 @@ function handleLogicalOperator(
   const joinOperator = key === '$or' || key === '$nor' ? 'OR' : 'AND';
   const conditions = Array.isArray(value)
     ? value.map(f => {
-        const entries = Object.entries(f);
+        const entries = !!f ? Object.entries(f) : [];
         return entries.map(([k, v]) => buildCondition(k, v, key));
       })
     : [buildCondition(key, value, parentPath)];