@mastra/memory 0.0.2-alpha.1 → 0.0.2-alpha.3

package/src/postgres/index.ts

@@ -1,5 +1,5 @@
-import { MastraMemory, MessageType, ThreadType } from '@mastra/core';
-import { ToolResultPart, CoreToolMessage, ToolInvocation, Message as AiMessage, TextPart } from 'ai';
+import { MastraMemory, MessageType, ThreadType, MessageResponse } from '@mastra/core';
+import { ToolResultPart, Message as AiMessage, TextPart } from 'ai';
 import crypto from 'crypto';
 import pg from 'pg';
 
@@ -7,236 +7,18 @@ const { Pool } = pg;
 
 export class PgMemory extends MastraMemory {
   private pool: pg.Pool;
-  private MAX_CONTEXT_TOKENS?: number;
-
+  hasTables: boolean = false;
   constructor(config: { connectionString: string; maxTokens?: number }) {
     super();
     this.pool = new Pool({ connectionString: config.connectionString });
     this.MAX_CONTEXT_TOKENS = config.maxTokens;
   }
 
-  async drop() {
-    const client = await this.pool.connect();
-    await client.query('DELETE FROM mastra_messages');
-    await client.query('DELETE FROM mastra_threads');
-    client.release();
-    await this.pool.end();
-  }
-
-  // Simplified token estimation
-  private estimateTokens(text: string): number {
-    return Math.ceil(text.split(' ').length * 1.3);
-  }
-
-  private processMessages(messages: MessageType[]): MessageType[] {
-    return messages.map(mssg => ({
-      ...mssg,
-      content: typeof mssg.content === 'string' ? JSON.parse((mssg as MessageType).content as string) : mssg.content,
-    }));
-  }
-
-  private convertToUIMessages(messages: MessageType[]): AiMessage[] {
-    function addToolMessageToChat({
-      toolMessage,
-      messages,
-      toolResultContents,
-    }: {
-      toolMessage: CoreToolMessage;
-      messages: Array<AiMessage>;
-      toolResultContents: Array<ToolResultPart>;
-    }): { chatMessages: Array<AiMessage>; toolResultContents: Array<ToolResultPart> } {
-      const chatMessages = messages.map(message => {
-        if (message.toolInvocations) {
-          return {
-            ...message,
-            toolInvocations: message.toolInvocations.map(toolInvocation => {
-              const toolResult = toolMessage.content.find(tool => tool.toolCallId === toolInvocation.toolCallId);
-
-              if (toolResult) {
-                return {
-                  ...toolInvocation,
-                  state: 'result',
-                  result: toolResult.result,
-                };
-              }
-
-              return toolInvocation;
-            }),
-          };
-        }
-
-        return message;
-      }) as Array<AiMessage>;
-
-      const resultContents = [...toolResultContents, ...toolMessage.content];
-
-      return { chatMessages, toolResultContents: resultContents };
-    }
-
-    const { chatMessages } = messages.reduce(
-      (obj: { chatMessages: Array<AiMessage>; toolResultContents: Array<ToolResultPart> }, message) => {
-        if (message.role === 'tool') {
-          return addToolMessageToChat({
-            toolMessage: message as CoreToolMessage,
-            messages: obj.chatMessages,
-            toolResultContents: obj.toolResultContents,
-          });
-        }
-
-        let textContent = '';
-        let toolInvocations: Array<ToolInvocation> = [];
-
-        if (typeof message.content === 'string') {
-          textContent = message.content;
-        } else if (Array.isArray(message.content)) {
-          for (const content of message.content) {
-            if (content.type === 'text') {
-              textContent += content.text;
-            } else if (content.type === 'tool-call') {
-              const toolResult = obj.toolResultContents.find(tool => tool.toolCallId === content.toolCallId);
-              toolInvocations.push({
-                state: toolResult ? 'result' : 'call',
-                toolCallId: content.toolCallId,
-                toolName: content.toolName,
-                args: content.args,
-                result: toolResult?.result,
-              });
-            }
-          }
-        }
-
-        obj.chatMessages.push({
-          id: message.id,
-          role: message.role as AiMessage['role'],
-          content: textContent,
-          toolInvocations,
-        });
-
-        return obj;
-      },
-      { chatMessages: [], toolResultContents: [] } as {
-        chatMessages: Array<AiMessage>;
-        toolResultContents: Array<ToolResultPart>;
-      },
-    );
-
-    return chatMessages;
-  }
-
-  async ensureTablesExist(): Promise<void> {
-    const client = await this.pool.connect();
-    try {
-      // Check if the threads table exists
-      const threadsResult = await client.query<{ exists: boolean }>(`
-                SELECT EXISTS (
-                    SELECT 1
-                    FROM information_schema.tables
-                    WHERE table_name = 'mastra_threads'
-                );
-            `);
-
-      if (!threadsResult?.rows?.[0]?.exists) {
-        await client.query(`
-                    CREATE TABLE IF NOT EXISTS mastra_threads (
-                        id UUID PRIMARY KEY,
-                        resourceid TEXT,
-                        title TEXT,
-                        created_at TIMESTAMP WITH TIME ZONE NOT NULL,
-                        updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
-                        metadata JSONB
-                    );
-                `);
-      }
-
-      // Check if the messages table exists
-      const messagesResult = await client.query<{ exists: boolean }>(`
-                SELECT EXISTS (
-                    SELECT 1
-                    FROM information_schema.tables
-                    WHERE table_name = 'mastra_messages'
-                );
-            `);
-
-      if (!messagesResult?.rows?.[0]?.exists) {
-        await client.query(`
-                    CREATE TABLE IF NOT EXISTS mastra_messages (
-                        id UUID PRIMARY KEY,
-                        content TEXT NOT NULL,
-                        role VARCHAR(20) NOT NULL,
-                        created_at TIMESTAMP WITH TIME ZONE NOT NULL,
-                        tool_call_ids TEXT DEFAULT NULL,
-                        tool_call_args TEXT DEFAULT NULL,
-                        tool_call_args_expire_at TIMESTAMP WITH TIME ZONE DEFAULT NULL,
-                        type VARCHAR(20) NOT NULL,
-                        tokens INTEGER DEFAULT NULL,
-                        thread_id UUID NOT NULL,
-                        FOREIGN KEY (thread_id) REFERENCES mastra_threads(id)
-                    );
-                `);
-      }
-    } finally {
-      client.release();
-    }
-  }
-
-  async updateThread(id: string, title: string, metadata: Record<string, unknown>): Promise<ThreadType> {
-    const client = await this.pool.connect();
-    try {
-      const result = await client.query<ThreadType>(
-        `
-                UPDATE mastra_threads
-                SET title = $1, metadata = $2, updated_at = NOW()
-                WHERE id = $3
-                RETURNING *
-                `,
-        [title, JSON.stringify(metadata), id],
-      );
-      return result?.rows?.[0]!;
-    } finally {
-      client.release();
-    }
-  }
-
-  async deleteThread(id: string): Promise<void> {
-    const client = await this.pool.connect();
-    try {
-      await client.query(
-        `
-                DELETE FROM mastra_messages
-                WHERE thread_id = $1
-                `,
-        [id],
-      );
-
-      await client.query(
-        `
-                DELETE FROM mastra_threads
-                WHERE id = $1
-                `,
-        [id],
-      );
-    } finally {
-      client.release();
-    }
-  }
-
-  async deleteMessage(id: string): Promise<void> {
-    const client = await this.pool.connect();
-    try {
-      await client.query(
-        `
-                DELETE FROM mastra_messages
-                WHERE id = $1
-                `,
-        [id],
-      );
-    } finally {
-      client.release();
-    }
-  }
+  /**
+   * Threads
+   */
 
   async getThreadById({ threadId }: { threadId: string }): Promise<ThreadType | null> {
-    console.log('getThreadById', threadId);
     await this.ensureTablesExist();
 
     const client = await this.pool.connect();
@@ -296,7 +78,52 @@ export class PgMemory extends MastraMemory {
     }
   }
 
-  async checkIfValidArgExists({ hashedToolCallArgs }: { hashedToolCallArgs: string }): Promise<boolean> {
+  async updateThread(id: string, title: string, metadata: Record<string, unknown>): Promise<ThreadType> {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query<ThreadType>(
+        `
+                UPDATE mastra_threads
+                SET title = $1, metadata = $2, updated_at = NOW()
+                WHERE id = $3
+                RETURNING *
+                `,
+        [title, JSON.stringify(metadata), id],
+      );
+      return result?.rows?.[0]!;
+    } finally {
+      client.release();
+    }
+  }
+
+  async deleteThread(id: string): Promise<void> {
+    const client = await this.pool.connect();
+    try {
+      await client.query(
+        `
+                DELETE FROM mastra_messages
+                WHERE thread_id = $1
+                `,
+        [id],
+      );
+
+      await client.query(
+        `
+                DELETE FROM mastra_threads
+                WHERE id = $1
+                `,
+        [id],
+      );
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Tool Cache
+   */
+
+  async validateToolCallArgs({ hashedArgs }: { hashedArgs: string }): Promise<boolean> {
     await this.ensureTablesExist();
 
     const client = await this.pool.connect();
@@ -311,7 +138,7 @@ export class PgMemory extends MastraMemory {
          AND tool_call_args_expire_at > $2
          ORDER BY created_at ASC
          LIMIT 1`,
-        [JSON.stringify([hashedToolCallArgs]), new Date().toISOString()],
+        [JSON.stringify([hashedArgs]), new Date().toISOString()],
       );
 
       return toolArgsResult.rows.length > 0;
@@ -323,7 +150,7 @@ export class PgMemory extends MastraMemory {
     }
   }
 
-  async getCachedToolResult({
+  async getToolResult({
     threadId,
     toolArgs,
     toolName,
@@ -409,17 +236,18 @@ export class PgMemory extends MastraMemory {
     }
   }
 
-  async getContextWindow({
+  async getContextWindow<T extends 'raw' | 'core_message'>({
     threadId,
     startDate,
     endDate,
+    format = 'raw' as T,
   }: {
+    format?: T;
     threadId: string;
     startDate?: Date;
     endDate?: Date;
-  }): Promise<MessageType[]> {
+  }) {
     await this.ensureTablesExist();
-    console.log('table exists');
     const client = await this.pool.connect();
 
     try {
@@ -448,9 +276,8 @@ export class PgMemory extends MastraMemory {
           [threadId, this.MAX_CONTEXT_TOKENS],
         );
 
-        console.log('result===', JSON.stringify(result.rows, null, 2));
-
-        return this.processMessages(result.rows);
+        console.log('Format', format);
+        return this.parseMessages(result.rows) as MessageResponse<T>;
       }
 
       //get all messages
@@ -470,9 +297,8 @@ export class PgMemory extends MastraMemory {
         [threadId],
       );
 
-      console.log('result===', JSON.stringify(result.rows, null, 2));
-
-      return this.processMessages(result.rows);
+      console.log('Format', format);
+      return this.parseMessages(result.rows) as MessageResponse<T>;
     } catch (error) {
       console.log('error getting context window====', error);
       return [];
@@ -481,6 +307,40 @@ export class PgMemory extends MastraMemory {
     }
   }
 
+  /**
+   * Messages
+   */
+
+  async getMessages({ threadId }: { threadId: string }): Promise<{ messages: MessageType[]; uiMessages: AiMessage[] }> {
+    await this.ensureTablesExist();
+
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query<MessageType>(
+        `
+                SELECT 
+                    id, 
+                    content, 
+                    role, 
+                    type,
+                    created_at AS createdAt, 
+                    thread_id AS threadId
+                FROM mastra_messages
+                WHERE thread_id = $1
+                ORDER BY created_at ASC
+            `,
+        [threadId],
+      );
+
+      const messages = this.parseMessages(result.rows);
+      const uiMessages = this.convertToUIMessages(messages);
+
+      return { messages, uiMessages };
+    } finally {
+      client.release();
+    }
+  }
+
   async saveMessages({ messages }: { messages: MessageType[] }): Promise<MessageType[]> {
     await this.ensureTablesExist();
 
@@ -511,8 +371,8 @@ export class PgMemory extends MastraMemory {
           // Check all args sequentially
           validArgExists = true; // Start true and set to false if any check fails
           for (let i = 0; i < hashedToolCallArgs.length; i++) {
-            const isValid = await this.checkIfValidArgExists({
-              hashedToolCallArgs: hashedToolCallArgs[i]!,
+            const isValid = await this.validateToolCallArgs({
+              hashedArgs: hashedToolCallArgs[i]!,
             });
             if (!isValid) {
               validArgExists = false;
@@ -559,33 +419,91 @@ export class PgMemory extends MastraMemory {
     }
   }
 
-  async getMessages({ threadId }: { threadId: string }): Promise<{ messages: MessageType[]; uiMessages: AiMessage[] }> {
-    await this.ensureTablesExist();
-
+  async deleteMessage(id: string): Promise<void> {
     const client = await this.pool.connect();
     try {
-      const result = await client.query<MessageType>(
+      await client.query(
         `
-                SELECT 
-                    id, 
-                    content, 
-                    role, 
-                    type,
-                    created_at AS createdAt, 
-                    thread_id AS threadId
-                FROM mastra_messages
-                WHERE thread_id = $1
-                ORDER BY created_at ASC
-            `,
-        [threadId],
+                DELETE FROM mastra_messages
+                WHERE id = $1
+                `,
+        [id],
       );
+    } finally {
+      client.release();
+    }
+  }
 
-      const messages = this.processMessages(result.rows);
-      const uiMessages = this.convertToUIMessages(messages);
+  /**
+   * Table Management
+   */
 
-      return { messages, uiMessages };
+  async drop() {
+    const client = await this.pool.connect();
+    await client.query('DELETE FROM mastra_messages');
+    await client.query('DELETE FROM mastra_threads');
+    client.release();
+    await this.pool.end();
+  }
+
+  async ensureTablesExist(): Promise<void> {
+    if (this.hasTables) {
+      return;
+    }
+
+    const client = await this.pool.connect();
+    try {
+      // Check if the threads table exists
+      const threadsResult = await client.query<{ exists: boolean }>(`
+                SELECT EXISTS (
+                    SELECT 1
+                    FROM information_schema.tables
+                    WHERE table_name = 'mastra_threads'
+                );
+            `);
+
+      if (!threadsResult?.rows?.[0]?.exists) {
+        await client.query(`
+                    CREATE TABLE IF NOT EXISTS mastra_threads (
+                        id UUID PRIMARY KEY,
+                        resourceid TEXT,
+                        title TEXT,
+                        created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+                        updated_at TIMESTAMP WITH TIME ZONE NOT NULL,
+                        metadata JSONB
+                    );
+                `);
+      }
+
+      // Check if the messages table exists
+      const messagesResult = await client.query<{ exists: boolean }>(`
+                SELECT EXISTS (
+                    SELECT 1
+                    FROM information_schema.tables
+                    WHERE table_name = 'mastra_messages'
+                );
+            `);
+
+      if (!messagesResult?.rows?.[0]?.exists) {
+        await client.query(`
+                    CREATE TABLE IF NOT EXISTS mastra_messages (
+                        id UUID PRIMARY KEY,
+                        content TEXT NOT NULL,
+                        role VARCHAR(20) NOT NULL,
+                        created_at TIMESTAMP WITH TIME ZONE NOT NULL,
+                        tool_call_ids TEXT DEFAULT NULL,
+                        tool_call_args TEXT DEFAULT NULL,
+                        tool_call_args_expire_at TIMESTAMP WITH TIME ZONE DEFAULT NULL,
+                        type VARCHAR(20) NOT NULL,
+                        tokens INTEGER DEFAULT NULL,
+                        thread_id UUID NOT NULL,
+                        FOREIGN KEY (thread_id) REFERENCES mastra_threads(id)
+                    );
+                `);
+      }
     } finally {
       client.release();
+      this.hasTables = true;
     }
   }
 }