@mastra/upstash 0.0.0-workflow-deno-20250616132510 → 0.0.0-working-memory-per-user-20250620163010

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.0.0-workflow-deno-20250616132510",
+  "version": "0.0.0-working-memory-per-user-20250620163010",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -31,12 +31,12 @@
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.0-workflow-deno-20250616132510",
-    "@internal/storage-test-utils": "0.0.8",
-    "@mastra/core": "0.0.0-workflow-deno-20250616132510"
+    "@internal/lint": "0.0.0-working-memory-per-user-20250620163010",
+    "@internal/storage-test-utils": "0.0.9",
+    "@mastra/core": "0.0.0-working-memory-per-user-20250620163010"
   },
   "peerDependencies": {
-    "@mastra/core": "0.0.0-workflow-deno-20250616132510"
+    "@mastra/core": "0.0.0-working-memory-per-user-20250620163010"
   },
   "scripts": {
     "pretest": "docker compose up -d",

package/src/storage/index.ts

@@ -1,9 +1,12 @@
+import { MessageList } from '@mastra/core/agent';
+import type { MastraMessageContentV2, MastraMessageV2 } from '@mastra/core/agent';
 import type { MetricResult, TestInfo } from '@mastra/core/eval';
-import type { StorageThreadType, MastraMessageV1, MastraMessageV2 } from '@mastra/core/memory';
+import type { StorageThreadType, MastraMessageV1 } from '@mastra/core/memory';
 import {
   MastraStorage,
   TABLE_MESSAGES,
   TABLE_THREADS,
+  TABLE_RESOURCES,
   TABLE_WORKFLOW_SNAPSHOT,
   TABLE_EVALS,
   TABLE_TRACES,
@@ -12,6 +15,7 @@ import type {
   TABLE_NAMES,
   StorageColumn,
   StorageGetMessagesArg,
+  StorageResourceType,
   EvalRow,
   WorkflowRuns,
   WorkflowRun,
@@ -21,7 +25,6 @@ import type {
 } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import { Redis } from '@upstash/redis';
-import { MessageList } from '../../../../packages/core/dist/agent/index.cjs';
 
 export interface UpstashConfig {
   url: string;
@@ -41,9 +44,11 @@ export class UpstashStore extends MastraStorage {
 
   public get supports(): {
     selectByIncludeResourceScope: boolean;
+    resourceWorkingMemory: boolean;
   } {
     return {
       selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
     };
   }
 
@@ -734,16 +739,7 @@ export class UpstashStore extends MastraStorage {
   }: StorageGetMessagesArg & { format?: 'v1' | 'v2' }): Promise<MastraMessageV1[] | MastraMessageV2[]> {
     const threadMessagesKey = this.getThreadMessagesKey(threadId);
     const allMessageIds = await this.redis.zrange(threadMessagesKey, 0, -1);
-    // When selectBy is undefined or selectBy.last is undefined, get ALL messages (not just 40)
-    let limit: number;
-    if (typeof selectBy?.last === 'number') {
-      limit = Math.max(0, selectBy.last);
-    } else if (selectBy?.last === false) {
-      limit = 0;
-    } else {
-      // No limit specified - get all messages
-      limit = Number.MAX_SAFE_INTEGER;
-    }
+    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: Number.MAX_SAFE_INTEGER });
 
     const messageIds = new Set<string>();
     const messageIdToThreadIds: Record<string, string> = {};
@@ -1187,4 +1183,99 @@ export class UpstashStore extends MastraStorage {
   async close(): Promise<void> {
     // No explicit cleanup needed for Upstash Redis
   }
+
+  async updateMessages(_args: {
+    messages: Partial<Omit<MastraMessageV2, 'createdAt'>> &
+      {
+        id: string;
+        content?: { metadata?: MastraMessageContentV2['metadata']; content?: MastraMessageContentV2['content'] };
+      }[];
+  }): Promise<MastraMessageV2[]> {
+    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

@@ -321,9 +321,9 @@ describe('UpstashStore', () => {
 
     it('should save and retrieve messages in order', async () => {
       const messages: MastraMessageV2[] = [
-        createSampleMessageV2({ threadId, content: 'First' }),
-        createSampleMessageV2({ threadId, content: 'Second' }),
-        createSampleMessageV2({ threadId, content: 'Third' }),
+        createSampleMessageV2({ threadId, content: { content: 'First' } }),
+        createSampleMessageV2({ threadId, content: { content: 'Second' } }),
+        createSampleMessageV2({ threadId, content: { content: 'Third' } }),
       ];
 
       await store.saveMessages({ messages, format: 'v2' });
@@ -344,16 +344,48 @@ describe('UpstashStore', () => {
       await store.saveThread({ thread: thread3 });
 
       const messages: MastraMessageV2[] = [
-        createSampleMessageV2({ threadId: 'thread-one', content: 'First', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-one', content: 'Second', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-one', content: 'Third', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'First' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'Second' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-one',
+          content: { content: 'Third' },
+          resourceId: 'cross-thread-resource',
+        }),
 
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Fourth', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Fifth', resourceId: 'cross-thread-resource' }),
-        createSampleMessageV2({ threadId: 'thread-two', content: 'Sixth', resourceId: 'cross-thread-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Fourth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Fifth' },
+          resourceId: 'cross-thread-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-two',
+          content: { content: 'Sixth' },
+          resourceId: 'cross-thread-resource',
+        }),
 
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Seventh', resourceId: 'other-resource' }),
-        createSampleMessageV2({ threadId: 'thread-three', content: 'Eighth', resourceId: 'other-resource' }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Seventh' },
+          resourceId: 'other-resource',
+        }),
+        createSampleMessageV2({
+          threadId: 'thread-three',
+          content: { content: 'Eighth' },
+          resourceId: 'other-resource',
+        }),
       ];
 
       await store.saveMessages({ messages: messages, format: 'v2' });
@@ -472,7 +504,7 @@ describe('UpstashStore', () => {
         await store.saveThread({ thread });
 
         const messages = Array.from({ length: 15 }, (_, i) =>
-          createSampleMessageV2({ threadId: thread.id, content: `Message ${i + 1}` }),
+          createSampleMessageV2({ threadId: thread.id, content: { content: `Message ${i + 1}` } }),
         );
 
         await store.saveMessages({ messages, format: 'v2' });
@@ -512,7 +544,7 @@ describe('UpstashStore', () => {
         await store.saveThread({ thread });
 
         const messages = Array.from({ length: 10 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `Message ${i + 1}` } });
           // Ensure different timestamps
           message.createdAt = new Date(Date.now() + i * 1000);
           return message;
@@ -545,13 +577,13 @@ describe('UpstashStore', () => {
         const tomorrow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
 
         const oldMessages = Array.from({ length: 3 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `Old Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `Old Message ${i + 1}` } });
           message.createdAt = yesterday;
           return message;
         });
 
         const newMessages = Array.from({ length: 4 }, (_, i) => {
-          const message = createSampleMessageV2({ threadId: thread.id, content: `New Message ${i + 1}` });
+          const message = createSampleMessageV2({ threadId: thread.id, content: { content: `New Message ${i + 1}` } });
           message.createdAt = tomorrow;
           return message;
         });

package/src/vector/index.ts

@@ -18,6 +18,12 @@ import { UpstashFilterTranslator } from './filter';
 export class UpstashVector extends MastraVector {
   private client: Index;
 
+  /**
+   * Creates a new UpstashVector instance.
+   * @param {object} params - The parameters for the UpstashVector.
+   * @param {string} params.url - The URL of the Upstash vector index.
+   * @param {string} params.token - The token for the Upstash vector index.
+   */
   constructor({ url, token }: { url: string; token: string }) {
     super();
     this.client = new Index({
@@ -26,7 +32,12 @@ export class UpstashVector extends MastraVector {
     });
   }
 
-  async upsert({ indexName, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]> {
+  /**
+   * Upserts vectors into the index.
+   * @param {UpsertVectorParams} params - The parameters for the upsert operation.
+   * @returns {Promise<string[]>} A promise that resolves to the IDs of the upserted vectors.
+   */
+  async upsert({ indexName: namespace, vectors, metadata, ids }: UpsertVectorParams): Promise<string[]> {
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
 
     const points = vectors.map((vector, index) => ({
@@ -36,28 +47,43 @@ export class UpstashVector extends MastraVector {
     }));
 
     await this.client.upsert(points, {
-      namespace: indexName,
+      namespace,
     });
     return generatedIds;
   }
 
+  /**
+   * Transforms a Mastra vector filter into an Upstash-compatible filter string.
+   * @param {VectorFilter} [filter] - The filter to transform.
+   * @returns {string | undefined} The transformed filter string, or undefined if no filter is provided.
+   */
   transformFilter(filter?: VectorFilter) {
     const translator = new UpstashFilterTranslator();
     return translator.translate(filter);
   }
 
+  /**
+   * 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).
+   * @returns {Promise<void>} A promise that resolves when the operation is complete.
+   */
   async createIndex(_params: CreateIndexParams): Promise<void> {
-    console.log('No need to call createIndex for Upstash');
+    this.logger.debug('No need to call createIndex for Upstash');
   }
 
+  /**
+   * Queries the vector index.
+   * @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.
+   */
   async query({
-    indexName,
+    indexName: namespace,
     queryVector,
     topK = 10,
     filter,
     includeVector = false,
   }: QueryVectorParams): Promise<QueryResult[]> {
-    const ns = this.client.namespace(indexName);
+    const ns = this.client.namespace(namespace);
 
     const filterString = this.transformFilter(filter);
     const results = await ns.query({
@@ -77,6 +103,10 @@ export class UpstashVector extends MastraVector {
     }));
   }
 
+  /**
+   * 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.
+   */
   async listIndexes(): Promise<string[]> {
     const indexes = await this.client.listNamespaces();
     return indexes.filter(Boolean);
@@ -85,30 +115,35 @@ export class UpstashVector extends MastraVector {
   /**
    * Retrieves statistics about a vector index.
    *
-   * @param {string} indexName - The name of the index to describe
+   * @param {string} indexName - The name of the namespace to describe
    * @returns A promise that resolves to the index statistics including dimension, count and metric
    */
-  async describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats> {
+  async describeIndex({ indexName: namespace }: DescribeIndexParams): Promise<IndexStats> {
     const info = await this.client.info();
 
     return {
       dimension: info.dimension,
-      count: info.namespaces?.[indexName]?.vectorCount || 0,
+      count: info.namespaces?.[namespace]?.vectorCount || 0,
       metric: info?.similarityFunction?.toLowerCase() as 'cosine' | 'euclidean' | 'dotproduct',
     };
   }
 
-  async deleteIndex({ indexName }: DeleteIndexParams): Promise<void> {
+  /**
+   * Deletes an index (namespace).
+   * @param {DeleteIndexParams} params - The parameters for the delete operation.
+   * @returns {Promise<void>} A promise that resolves when the deletion is complete.
+   */
+  async deleteIndex({ indexName: namespace }: DeleteIndexParams): Promise<void> {
     try {
-      await this.client.deleteNamespace(indexName);
+      await this.client.deleteNamespace(namespace);
     } catch (error) {
-      console.error('Failed to delete namespace:', error);
+      this.logger.error('Failed to delete namespace:', error);
     }
   }
 
   /**
    * Updates a vector by its ID with the provided vector and/or metadata.
-   * @param indexName - The name of the index containing the vector.
+   * @param indexName - The name of the namespace containing the vector.
    * @param id - The ID of the vector to update.
    * @param update - An object containing the vector and/or metadata to update.
    * @param update.vector - An optional array of numbers representing the new vector.
@@ -116,7 +151,7 @@ export class UpstashVector extends MastraVector {
    * @returns A promise that resolves when the update is complete.
    * @throws Will throw an error if no updates are provided or if the update operation fails.
    */
-  async updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void> {
+  async updateVector({ indexName: namespace, id, update }: UpdateVectorParams): Promise<void> {
     try {
       if (!update.vector && !update.metadata) {
         throw new Error('No update data provided');
@@ -143,27 +178,27 @@ export class UpstashVector extends MastraVector {
       };
 
       await this.client.upsert(points, {
-        namespace: indexName,
+        namespace,
       });
     } catch (error: any) {
-      throw new Error(`Failed to update vector by id: ${id} for index name: ${indexName}: ${error.message}`);
+      throw new Error(`Failed to update vector by id: ${id} for index name: ${namespace}: ${error.message}`);
     }
   }
 
   /**
    * Deletes a vector by its ID.
-   * @param indexName - The name of the index containing the vector.
+   * @param indexName - The name of the namespace containing the vector.
    * @param id - The ID of the vector to delete.
    * @returns A promise that resolves when the deletion is complete.
    * @throws Will throw an error if the deletion operation fails.
    */
-  async deleteVector({ indexName, id }: DeleteVectorParams): Promise<void> {
+  async deleteVector({ indexName: namespace, id }: DeleteVectorParams): Promise<void> {
     try {
       await this.client.delete(id, {
-        namespace: indexName,
+        namespace,
       });
     } catch (error) {
-      console.error(`Failed to delete vector by id: ${id} for index name: ${indexName}:`, error);
+      this.logger.error(`Failed to delete vector by id: ${id} for namespace: ${namespace}:`, error);
     }
   }
 }