@mastra/upstash 0.11.1-alpha.1 → 0.12.0-alpha.3

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/upstash@0.11.1-alpha.1 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.12.0-alpha.3 build /home/runner/work/mastra/mastra/stores/upstash
 > 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 10322ms
+TSC ⚡️ Build success in 10415ms
 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/upstash/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/upstash/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11265ms
+DTS ⚡️ Build success in 12348ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 55.79 KB
-CJS ⚡️ Build success in 1691ms
-ESM dist/index.js 54.97 KB
-ESM ⚡️ Build success in 1693ms
+CJS dist/index.cjs 58.93 KB
+CJS ⚡️ Build success in 2021ms
+ESM dist/index.js 58.11 KB
+ESM ⚡️ Build success in 2039ms

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/upstash
 
+## 0.12.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.11.1-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
+- Updated dependencies [15e9d26]
+- Updated dependencies [07d6d88]
+- Updated dependencies [5d74aab]
+- Updated dependencies [144eb0b]
+  - @mastra/core@0.10.7-alpha.2
+
 ## 0.11.1-alpha.1
 
 ### Patch Changes

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

@@ -11,6 +11,7 @@ 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';
@@ -18,6 +19,7 @@ import type { QueryVectorParams } from '@mastra/core/vector';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageGetTracesArg } 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 { UpdateVectorParams } from '@mastra/core/vector';
@@ -42,9 +44,9 @@ declare interface UpstashConfig {
 export { UpstashConfig }
 export { UpstashConfig as UpstashConfig_alias_1 }
 
-export declare class UpstashFilterTranslator extends BaseFilterTranslator {
+export declare class UpstashFilterTranslator extends BaseFilterTranslator<UpstashVectorFilter, string | undefined> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): string | undefined;
+    translate(filter?: UpstashVectorFilter): string | undefined;
     private translateNode;
     private readonly COMPARISON_OPS;
     private translateOperator;
@@ -56,11 +58,18 @@ export declare class UpstashFilterTranslator extends BaseFilterTranslator {
     private joinConditions;
 }
 
+declare type UpstashOperatorValueMap = Omit<OperatorValueMap, '$options' | '$elemMatch'> & {
+    $contains: string;
+};
+
+declare type UpstashQueryVectorParams = QueryVectorParams<UpstashVectorFilter>;
+
 declare class UpstashStore extends MastraStorage {
     private redis;
     constructor(config: UpstashConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
     };
     private transformEvalRecord;
     private parseJSON;
@@ -221,11 +230,22 @@ declare class UpstashStore extends MastraStorage {
             };
         }[];
     }): Promise<MastraMessageV2[]>;
+    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>;
 }
 export { UpstashStore }
 export { UpstashStore as UpstashStore_alias_1 }
 
-declare class UpstashVector extends MastraVector {
+declare class UpstashVector extends MastraVector<UpstashVectorFilter> {
     private client;
     /**
      * Creates a new UpstashVector instance.
@@ -245,10 +265,10 @@ declare class UpstashVector extends MastraVector {
     upsert({ indexName: namespace, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]>;
     /**
      * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-     * @param {VectorFilter} [filter] - The filter to transform.
+     * @param {UpstashVectorFilter} [filter] - The filter to transform.
      * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
      */
-    transformFilter(filter?: VectorFilter): string | undefined;
+    transformFilter(filter?: UpstashVectorFilter): string | undefined;
     /**
      * Creates a new index. For Upstash, this is a no-op as indexes (known as namespaces in Upstash) are created on-the-fly.
      * @param {CreateIndexParams} _params - The parameters for creating the index (ignored).
@@ -260,7 +280,7 @@ declare class UpstashVector extends MastraVector {
      * @param {QueryVectorParams} params - The parameters for the query operation. indexName is the namespace in Upstash.
      * @returns {Promise<QueryResult[]>} A promise that resolves to the query results.
      */
-    query({ indexName: namespace, queryVector, topK, filter, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName: namespace, queryVector, topK, filter, includeVector, }: UpstashQueryVectorParams): Promise<QueryResult[]>;
     /**
      * Lists all namespaces in the Upstash vector index, which correspond to indexes.
      * @returns {Promise<string[]>} A promise that resolves to a list of index names.
@@ -302,4 +322,6 @@ declare class UpstashVector extends MastraVector {
 export { UpstashVector }
 export { UpstashVector as UpstashVector_alias_1 }
 
+export declare type UpstashVectorFilter = VectorFilter<keyof UpstashOperatorValueMap, UpstashOperatorValueMap>;
+
 export { }

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

@@ -11,6 +11,7 @@ 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';
@@ -18,6 +19,7 @@ import type { QueryVectorParams } from '@mastra/core/vector';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageGetTracesArg } 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 { UpdateVectorParams } from '@mastra/core/vector';
@@ -42,9 +44,9 @@ declare interface UpstashConfig {
 export { UpstashConfig }
 export { UpstashConfig as UpstashConfig_alias_1 }
 
-export declare class UpstashFilterTranslator extends BaseFilterTranslator {
+export declare class UpstashFilterTranslator extends BaseFilterTranslator<UpstashVectorFilter, string | undefined> {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: VectorFilter): string | undefined;
+    translate(filter?: UpstashVectorFilter): string | undefined;
     private translateNode;
     private readonly COMPARISON_OPS;
     private translateOperator;
@@ -56,11 +58,18 @@ export declare class UpstashFilterTranslator extends BaseFilterTranslator {
     private joinConditions;
 }
 
+declare type UpstashOperatorValueMap = Omit<OperatorValueMap, '$options' | '$elemMatch'> & {
+    $contains: string;
+};
+
+declare type UpstashQueryVectorParams = QueryVectorParams<UpstashVectorFilter>;
+
 declare class UpstashStore extends MastraStorage {
     private redis;
     constructor(config: UpstashConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
     };
     private transformEvalRecord;
     private parseJSON;
@@ -221,11 +230,22 @@ declare class UpstashStore extends MastraStorage {
             };
         }[];
     }): Promise<MastraMessageV2[]>;
+    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>;
 }
 export { UpstashStore }
 export { UpstashStore as UpstashStore_alias_1 }
 
-declare class UpstashVector extends MastraVector {
+declare class UpstashVector extends MastraVector<UpstashVectorFilter> {
     private client;
     /**
      * Creates a new UpstashVector instance.
@@ -245,10 +265,10 @@ declare class UpstashVector extends MastraVector {
     upsert({ indexName: namespace, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]>;
     /**
      * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-     * @param {VectorFilter} [filter] - The filter to transform.
+     * @param {UpstashVectorFilter} [filter] - The filter to transform.
      * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
      */
-    transformFilter(filter?: VectorFilter): string | undefined;
+    transformFilter(filter?: UpstashVectorFilter): string | undefined;
     /**
      * Creates a new index. For Upstash, this is a no-op as indexes (known as namespaces in Upstash) are created on-the-fly.
      * @param {CreateIndexParams} _params - The parameters for creating the index (ignored).
@@ -260,7 +280,7 @@ declare class UpstashVector extends MastraVector {
      * @param {QueryVectorParams} params - The parameters for the query operation. indexName is the namespace in Upstash.
      * @returns {Promise<QueryResult[]>} A promise that resolves to the query results.
      */
-    query({ indexName: namespace, queryVector, topK, filter, includeVector, }: QueryVectorParams): Promise<QueryResult[]>;
+    query({ indexName: namespace, queryVector, topK, filter, includeVector, }: UpstashQueryVectorParams): Promise<QueryResult[]>;
     /**
      * Lists all namespaces in the Upstash vector index, which correspond to indexes.
      * @returns {Promise<string[]>} A promise that resolves to a list of index names.
@@ -302,4 +322,6 @@ declare class UpstashVector extends MastraVector {
 export { UpstashVector }
 export { UpstashVector as UpstashVector_alias_1 }
 
+export declare type UpstashVectorFilter = VectorFilter<keyof UpstashOperatorValueMap, UpstashOperatorValueMap>;
+
 export { }

package/dist/index.cjs

@@ -20,7 +20,8 @@ var UpstashStore = class extends storage.MastraStorage {
   }
   get supports() {
     return {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   transformEvalRecord(record) {
@@ -698,6 +699,23 @@ var UpstashStore = class extends storage.MastraStorage {
           const key = this.getMessageKey(message.threadId, message.id);
           const createdAtScore = new Date(message.createdAt).getTime();
           const score = message._index !== void 0 ? message._index : createdAtScore;
+          const existingKeyPattern = this.getMessageKey("*", message.id);
+          const keys = await this.scanKeys(existingKeyPattern);
+          if (keys.length > 0) {
+            const pipeline2 = this.redis.pipeline();
+            keys.forEach((key2) => pipeline2.get(key2));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg) => msg !== null
+            );
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = this.getMessageKey(existingMessage.threadId, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
+              }
+            }
+          }
           pipeline.set(key, message);
           pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
             score,
@@ -1173,6 +1191,75 @@ var UpstashStore = class extends storage.MastraStorage {
     this.logger.error("updateMessages is not yet implemented in UpstashStore");
     throw new Error("Method not implemented");
   }
+  async getResourceById({ resourceId }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.redis.get(key);
+      if (!data) {
+        return null;
+      }
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        updatedAt: new Date(data.updatedAt),
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory,
+        metadata: typeof data.metadata === "string" ? JSON.parse(data.metadata) : data.metadata
+      };
+    } catch (error) {
+      this.logger.error("Error getting resource by ID:", error);
+      throw error;
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const key = `${storage.TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString()
+      };
+      await this.redis.set(key, serializedResource);
+      return resource;
+    } catch (error) {
+      this.logger.error("Error saving resource:", error);
+      throw error;
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      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()
+      };
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error("Error updating resource:", error);
+      throw error;
+    }
+  }
 };
 var UpstashFilterTranslator = class extends filter.BaseFilterTranslator {
   getSupportedOperators() {
@@ -1413,7 +1500,7 @@ var UpstashVector = class extends vector.MastraVector {
   }
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
   transformFilter(filter) {

package/dist/index.js

@@ -1,6 +1,6 @@
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { MastraStorage, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES, TABLE_THREADS } from '@mastra/core/storage';
+import { MastraStorage, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_TRACES, TABLE_THREADS, TABLE_RESOURCES } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MastraVector } from '@mastra/core/vector';
 import { Index } from '@upstash/vector';
@@ -18,7 +18,8 @@ var UpstashStore = class extends MastraStorage {
   }
   get supports() {
     return {
-      selectByIncludeResourceScope: true
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true
     };
   }
   transformEvalRecord(record) {
@@ -696,6 +697,23 @@ var UpstashStore = class extends MastraStorage {
           const key = this.getMessageKey(message.threadId, message.id);
           const createdAtScore = new Date(message.createdAt).getTime();
           const score = message._index !== void 0 ? message._index : createdAtScore;
+          const existingKeyPattern = this.getMessageKey("*", message.id);
+          const keys = await this.scanKeys(existingKeyPattern);
+          if (keys.length > 0) {
+            const pipeline2 = this.redis.pipeline();
+            keys.forEach((key2) => pipeline2.get(key2));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg) => msg !== null
+            );
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = this.getMessageKey(existingMessage.threadId, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId), existingMessage.id);
+              }
+            }
+          }
           pipeline.set(key, message);
           pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
             score,
@@ -1171,6 +1189,75 @@ var UpstashStore = class extends MastraStorage {
     this.logger.error("updateMessages is not yet implemented in UpstashStore");
     throw new Error("Method not implemented");
   }
+  async getResourceById({ resourceId }) {
+    try {
+      const key = `${TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.redis.get(key);
+      if (!data) {
+        return null;
+      }
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        updatedAt: new Date(data.updatedAt),
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === "object" ? JSON.stringify(data.workingMemory) : data.workingMemory,
+        metadata: typeof data.metadata === "string" ? JSON.parse(data.metadata) : data.metadata
+      };
+    } catch (error) {
+      this.logger.error("Error getting resource by ID:", error);
+      throw error;
+    }
+  }
+  async saveResource({ resource }) {
+    try {
+      const key = `${TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString()
+      };
+      await this.redis.set(key, serializedResource);
+      return resource;
+    } catch (error) {
+      this.logger.error("Error saving resource:", error);
+      throw error;
+    }
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    try {
+      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()
+      };
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error("Error updating resource:", error);
+      throw error;
+    }
+  }
 };
 var UpstashFilterTranslator = class extends BaseFilterTranslator {
   getSupportedOperators() {
@@ -1411,7 +1498,7 @@ var UpstashVector = class extends MastraVector {
   }
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
   transformFilter(filter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.11.1-alpha.1",
+  "version": "0.12.0-alpha.3",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -27,16 +27,16 @@
     "@microsoft/api-extractor": "^7.52.8",
     "@types/node": "^20.19.0",
     "dotenv": "^16.5.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": {
     "pretest": "docker compose up -d",

package/src/storage/index.ts

@@ -7,6 +7,7 @@ import {
   MastraStorage,
   TABLE_MESSAGES,
   TABLE_THREADS,
+  TABLE_RESOURCES,
   TABLE_WORKFLOW_SNAPSHOT,
   TABLE_EVALS,
   TABLE_TRACES,
@@ -15,6 +16,7 @@ import type {
   TABLE_NAMES,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageResourceType,
   EvalRow,
   WorkflowRuns,
   WorkflowRun,
@@ -43,9 +45,11 @@ export class UpstashStore extends MastraStorage {
 
   public get supports(): {
     selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
   } {
     return {
       selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
     };
   }
 
@@ -853,6 +857,27 @@ export class UpstashStore extends MastraStorage {
           const createdAtScore = new Date(message.createdAt).getTime();
           const score = message._index !== undefined ? message._index : createdAtScore;
 
+          // Check if this message id exists in another thread
+          const existingKeyPattern = this.getMessageKey('*', message.id);
+          const keys = await this.scanKeys(existingKeyPattern);
+
+          if (keys.length > 0) {
+            const pipeline2 = this.redis.pipeline();
+            keys.forEach(key => pipeline2.get(key));
+            const results = await pipeline2.exec();
+            const existingMessages = results.filter(
+              (msg): msg is MastraMessageV2 | MastraMessageV1 => msg !== null,
+            ) as (MastraMessageV2 | MastraMessageV1)[];
+            for (const existingMessage of existingMessages) {
+              const existingMessageKey = this.getMessageKey(existingMessage.threadId!, existingMessage.id);
+              if (existingMessage && existingMessage.threadId !== message.threadId) {
+                pipeline.del(existingMessageKey);
+                // Remove from old thread's sorted set
+                pipeline.zrem(this.getThreadMessagesKey(existingMessage.threadId!), existingMessage.id);
+              }
+            }
+          }
+
           // Store the message data
           pipeline.set(key, message);
 
@@ -1508,4 +1533,88 @@ export class UpstashStore extends MastraStorage {
     this.logger.error('updateMessages is not yet implemented in UpstashStore');
     throw new Error('Method not implemented');
   }
+
+  async getResourceById({ resourceId }: { resourceId: string }): Promise<StorageResourceType | null> {
+    try {
+      const key = `${TABLE_RESOURCES}:${resourceId}`;
+      const data = await this.redis.get<StorageResourceType>(key);
+
+      if (!data) {
+        return null;
+      }
+
+      return {
+        ...data,
+        createdAt: new Date(data.createdAt),
+        updatedAt: new Date(data.updatedAt),
+        // Ensure workingMemory is always returned as a string, regardless of automatic parsing
+        workingMemory: typeof data.workingMemory === 'object' ? JSON.stringify(data.workingMemory) : data.workingMemory,
+        metadata: typeof data.metadata === 'string' ? JSON.parse(data.metadata) : data.metadata,
+      };
+    } catch (error) {
+      this.logger.error('Error getting resource by ID:', error);
+      throw error;
+    }
+  }
+
+  async saveResource({ resource }: { resource: StorageResourceType }): Promise<StorageResourceType> {
+    try {
+      const key = `${TABLE_RESOURCES}:${resource.id}`;
+      const serializedResource = {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata),
+        createdAt: resource.createdAt.toISOString(),
+        updatedAt: resource.updatedAt.toISOString(),
+      };
+
+      await this.redis.set(key, serializedResource);
+
+      return resource;
+    } catch (error) {
+      this.logger.error('Error saving resource:', error);
+      throw error;
+    }
+  }
+
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata,
+  }: {
+    resourceId: string;
+    workingMemory?: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<StorageResourceType> {
+    try {
+      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(),
+      };
+
+      await this.saveResource({ resource: updatedResource });
+      return updatedResource;
+    } catch (error) {
+      this.logger.error('Error updating resource:', error);
+      throw error;
+    }
+  }
 }

package/src/storage/upstash.test.ts

@@ -498,6 +498,81 @@ describe('UpstashStore', () => {
       expect(retrievedMessages[0].content).toEqual(messages[0].content);
     });
 
+    it('should upsert messages: duplicate id+threadId results in update, not duplicate row', async () => {
+      const thread = await createSampleThread();
+      await store.saveThread({ thread });
+      const baseMessage = createSampleMessageV2({
+        threadId: thread.id,
+        createdAt: new Date(),
+        content: { content: 'Original' },
+        resourceId: thread.resourceId,
+      });
+
+      // Insert the message for the first time
+      await store.saveMessages({ messages: [baseMessage], format: 'v2' });
+
+      // Insert again with the same id and threadId but different content
+      const updatedMessage = {
+        ...createSampleMessageV2({
+          threadId: thread.id,
+          createdAt: new Date(),
+          content: { content: 'Updated' },
+          resourceId: thread.resourceId,
+        }),
+        id: baseMessage.id,
+      };
+
+      await store.saveMessages({ messages: [updatedMessage], format: 'v2' });
+
+      // Retrieve messages for the thread
+      const retrievedMessages = await store.getMessages({ threadId: thread.id, format: 'v2' });
+
+      // Only one message should exist for that id+threadId
+      expect(retrievedMessages.filter(m => m.id === baseMessage.id)).toHaveLength(1);
+
+      // The content should be the updated one
+      expect(retrievedMessages.find(m => m.id === baseMessage.id)?.content.content).toBe('Updated');
+    });
+
+    it('should upsert messages: duplicate id and different threadid', async () => {
+      const thread1 = await createSampleThread();
+      const thread2 = await createSampleThread();
+      await store.saveThread({ thread: thread1 });
+      await store.saveThread({ thread: thread2 });
+
+      const message = createSampleMessageV2({
+        threadId: thread1.id,
+        createdAt: new Date(),
+        content: { content: 'Thread1 Content' },
+        resourceId: thread1.resourceId,
+      });
+
+      // Insert message into thread1
+      await store.saveMessages({ messages: [message], format: 'v2' });
+
+      // Attempt to insert a message with the same id but different threadId
+      const conflictingMessage = {
+        ...createSampleMessageV2({
+          threadId: thread2.id, // different thread
+          content: { content: 'Thread2 Content' },
+          resourceId: thread2.resourceId,
+        }),
+        id: message.id,
+      };
+
+      // Save should move the message to the new thread
+      await store.saveMessages({ messages: [conflictingMessage], format: 'v2' });
+
+      // Retrieve messages for both threads
+      const thread1Messages = await store.getMessages({ threadId: thread1.id, format: 'v2' });
+      const thread2Messages = await store.getMessages({ threadId: thread2.id, format: 'v2' });
+
+      // Thread 1 should NOT have the message with that id
+      expect(thread1Messages.find(m => m.id === message.id)).toBeUndefined();
+
+      // Thread 2 should have the message with that id
+      expect(thread2Messages.find(m => m.id === message.id)?.content.content).toBe('Thread2 Content');
+    });
     describe('getMessagesPaginated', () => {
       it('should return paginated messages with total count', async () => {
         const thread = createSampleThread();

package/src/vector/filter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
 
+import type { UpstashVectorFilter } from './filter';
 import { UpstashFilterTranslator } from './filter';
 
 describe('UpstashFilterTranslator', () => {
@@ -22,7 +23,7 @@ describe('UpstashFilterTranslator', () => {
 
   it('translates nested paths', () => {
     expect(translator.translate({ 'geography.continent': 'Asia' })).toBe("geography.continent = 'Asia'");
-    expect(translator.translate({ geography: { continent: 'Asia' } })).toBe("geography.continent = 'Asia'");
+    expect(translator.translate({ geography: { continent: 'Asia' } } as any)).toBe("geography.continent = 'Asia'");
   });
 
   it('translates comparison operators', () => {
@@ -65,7 +66,7 @@ describe('UpstashFilterTranslator', () => {
   });
 
   it('translates complex nested conditions', () => {
-    const filter = {
+    const filter: UpstashVectorFilter = {
       $and: [
         { population: { $gte: 1000000 } },
         { 'geography.continent': 'Asia' },
@@ -154,7 +155,7 @@ describe('UpstashFilterTranslator', () => {
 
   describe('complex scenarios', () => {
     it('deeply nested logical operators', () => {
-      const filter = {
+      const filter: UpstashVectorFilter = {
         $or: [
           {
             $and: [
@@ -214,7 +215,7 @@ describe('UpstashFilterTranslator', () => {
     });
 
     it('complex filtering with all operator types', () => {
-      const filter = {
+      const filter: UpstashVectorFilter = {
         $and: [
           {
             $or: [{ name: { $regex: 'San*' } }, { name: { $regex: 'New*' } }],
@@ -531,7 +532,7 @@ describe('UpstashFilterTranslator', () => {
     });
 
     it('throws error for invalid $not operator', () => {
-      expect(() => translator.translate({ field: { $not: true } })).toThrow();
+      expect(() => translator.translate({ field: { $not: true } } as any)).toThrow();
     });
 
     it('throws error for regex operators', () => {
@@ -539,7 +540,7 @@ describe('UpstashFilterTranslator', () => {
       expect(() => translator.translate(filter)).toThrow();
     });
     it('throws error for non-logical operators at top level', () => {
-      const invalidFilters = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
+      const invalidFilters: any = [{ $gt: 100 }, { $in: ['value1', 'value2'] }, { $eq: true }];
 
       invalidFilters.forEach(filter => {
         expect(() => translator.translate(filter)).toThrow(/Invalid top-level operator/);

package/src/vector/filter.ts

@@ -1,7 +1,13 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
-import type { FieldCondition, OperatorSupport, VectorFilter } from '@mastra/core/vector/filter';
+import type { OperatorSupport, VectorFilter, OperatorValueMap } from '@mastra/core/vector/filter';
 
-export class UpstashFilterTranslator extends BaseFilterTranslator {
+type UpstashOperatorValueMap = Omit<OperatorValueMap, '$options' | '$elemMatch'> & {
+  $contains: string;
+};
+
+export type UpstashVectorFilter = VectorFilter<keyof UpstashOperatorValueMap, UpstashOperatorValueMap>;
+
+export class UpstashFilterTranslator extends BaseFilterTranslator<UpstashVectorFilter, string | undefined> {
   protected override getSupportedOperators(): OperatorSupport {
     return {
       ...BaseFilterTranslator.DEFAULT_OPERATORS,
@@ -11,13 +17,13 @@ export class UpstashFilterTranslator extends BaseFilterTranslator {
     };
   }
 
-  translate(filter?: VectorFilter): string | undefined {
+  translate(filter?: UpstashVectorFilter): string | undefined {
     if (this.isEmpty(filter)) return undefined;
     this.validateFilter(filter);
     return this.translateNode(filter);
   }
 
-  private translateNode(node: VectorFilter | FieldCondition, path: string = ''): string {
+  private translateNode(node: UpstashVectorFilter, path: string = ''): string {
     if (this.isRegex(node)) {
       throw new Error('Direct regex pattern format is not supported in Upstash');
     }

package/src/vector/index.test.ts

@@ -1146,7 +1146,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
           vectorStore.query({
             indexName: filterIndexName,
             queryVector: createVector(0),
-            filter: { field: { $invalidOp: 'value' } },
+            filter: { field: { $invalidOp: 'value' } as any },
           }),
         ).rejects.toThrow();
       });
@@ -1196,7 +1196,7 @@ describe.skipIf(!process.env.UPSTASH_VECTOR_URL || !process.env.UPSTASH_VECTOR_T
         const results = await vectorStore.query({
           indexName: filterIndexName,
           queryVector: createVector(0),
-          filter: { $and: { not: 'an array' } },
+          filter: { $and: { not: 'an array' } as any },
         });
         expect(results.length).toBeGreaterThan(0);
       });

package/src/vector/index.ts

@@ -11,12 +11,14 @@ import type {
   UpdateVectorParams,
   UpsertVectorParams,
 } from '@mastra/core/vector';
-import type { VectorFilter } from '@mastra/core/vector/filter';
 import { Index } from '@upstash/vector';
 
 import { UpstashFilterTranslator } from './filter';
+import type { UpstashVectorFilter } from './filter';
 
-export class UpstashVector extends MastraVector {
+type UpstashQueryVectorParams = QueryVectorParams<UpstashVectorFilter>;
+
+export class UpstashVector extends MastraVector<UpstashVectorFilter> {
   private client: Index;
 
   /**
@@ -67,10 +69,10 @@ export class UpstashVector extends MastraVector {
 
   /**
    * Transforms a Mastra vector filter into an Upstash-compatible filter string.
-   * @param {VectorFilter} [filter] - The filter to transform.
+   * @param {UpstashVectorFilter} [filter] - The filter to transform.
    * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
    */
-  transformFilter(filter?: VectorFilter) {
+  transformFilter(filter?: UpstashVectorFilter) {
     const translator = new UpstashFilterTranslator();
     return translator.translate(filter);
   }
@@ -95,7 +97,7 @@ export class UpstashVector extends MastraVector {
     topK = 10,
     filter,
     includeVector = false,
-  }: QueryVectorParams): Promise<QueryResult[]> {
+  }: UpstashQueryVectorParams): Promise<QueryResult[]> {
     try {
       const ns = this.client.namespace(namespace);