npm - @mastra/memory - Versions diffs - 0.14.3-alpha.1 → 0.14.3-alpha.2 - Mend

@mastra/memory 0.14.3-alpha.1 → 0.14.3-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/CHANGELOG.md +10 -0
package/package.json +16 -3
package/.turbo/turbo-build.log +0 -8
package/eslint.config.js +0 -12
package/integration-tests-v5/.env.test +0 -5
package/integration-tests-v5/CHANGELOG.md +0 -175
package/integration-tests-v5/docker-compose.yml +0 -39
package/integration-tests-v5/node_modules/.bin/next +0 -21
package/integration-tests-v5/node_modules/.bin/tsc +0 -21
package/integration-tests-v5/node_modules/.bin/tsserver +0 -21
package/integration-tests-v5/node_modules/.bin/vitest +0 -21
package/integration-tests-v5/package.json +0 -43
package/integration-tests-v5/src/agent-memory.test.ts +0 -621
package/integration-tests-v5/src/mastra/agents/weather.ts +0 -75
package/integration-tests-v5/src/mastra/index.ts +0 -13
package/integration-tests-v5/src/mastra/tools/weather.ts +0 -24
package/integration-tests-v5/src/processors.test.ts +0 -604
package/integration-tests-v5/src/streaming-memory.test.ts +0 -367
package/integration-tests-v5/src/test-utils.ts +0 -147
package/integration-tests-v5/src/working-memory.test.ts +0 -1064
package/integration-tests-v5/tsconfig.json +0 -13
package/integration-tests-v5/vitest.config.ts +0 -18
package/src/index.ts +0 -1040
package/src/processors/index.test.ts +0 -246
package/src/processors/index.ts +0 -2
package/src/processors/token-limiter.ts +0 -159
package/src/processors/tool-call-filter.ts +0 -77
package/src/tools/working-memory.ts +0 -154
package/tsconfig.build.json +0 -9
package/tsconfig.json +0 -5
package/tsup.config.ts +0 -17
package/vitest.config.ts +0 -11

package/integration-tests-v5/src/streaming-memory.test.ts DELETED Viewed

@@ -1,367 +0,0 @@
-import { spawn } from 'node:child_process';
-import { randomUUID } from 'node:crypto';
-import type { UUID } from 'node:crypto';
-import { createServer } from 'node:net';
-import path from 'node:path';
-import { openai } from '@ai-sdk/openai';
-import { useChat } from '@ai-sdk/react';
-import { Mastra } from '@mastra/core';
-import { Agent } from '@mastra/core/agent';
-import { renderHook, act, waitFor } from '@testing-library/react';
-import type { UIMessage } from 'ai';
-import { DefaultChatTransport, isToolUIPart } from 'ai';
-import { JSDOM } from 'jsdom';
-import { describe, expect, it, beforeAll, afterAll } from 'vitest';
-import { memory, weatherAgent } from './mastra/agents/weather';
-import { weatherTool } from './mastra/tools/weather';
-// Helper to find an available port
-async function getAvailablePort(): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const server = createServer();
-    server.listen(0, () => {
-      const { port } = server.address() as { port: number };
-      server.close(() => resolve(port));
-    });
-    server.on('error', reject);
-  });
-}
-// Set up JSDOM environment for React testing
-const dom = new JSDOM('<!doctype html><html><body></body></html>', {
-  url: 'http://localhost',
-  pretendToBeVisual: true,
-  resources: 'usable',
-});
-// @ts-ignore - JSDOM types don't match exactly but this works for testing
-global.window = dom.window;
-global.document = dom.window.document;
-global.navigator = dom.window.navigator;
-global.fetch = global.fetch || fetch;
-describe('Memory Streaming Tests', () => {
-  it('should handle multiple tool calls in memory thread history', async () => {
-    // Create agent with memory and tools
-    const agent = new Agent({
-      name: 'test',
-      instructions:
-        'You are a weather agent. When asked about weather in any city, use the get_weather tool with the city name as the postal code. Respond in a pirate accent and dont use the degrees symbol, print the word degrees when needed.',
-      model: openai('gpt-4o'),
-      memory,
-      tools: { get_weather: weatherTool },
-    });
-    const threadId = randomUUID();
-    const resourceId = 'test-resource';
-    // First weather check
-    const stream1 = await agent.streamVNext('what is the weather in LA?', {
-      threadId,
-      resourceId,
-    });
-    // Collect first stream
-    const chunks1: string[] = [];
-    for await (const chunk of stream1.fullStream) {
-      if (chunk.type === `text-delta`) {
-        chunks1.push(chunk.payload.text);
-      }
-    }
-    const response1 = chunks1.join('');
-    expect(chunks1.length).toBeGreaterThan(0);
-    expect(response1).toContain('70 degrees');
-    // Second weather check
-    const stream2 = await agent.streamVNext('what is the weather in Seattle?', {
-      threadId,
-      resourceId,
-      format: 'aisdk', // use aisdk output type this time just for fun
-    });
-    // Collect second stream
-    const chunks2: string[] = [];
-    for await (const chunk of stream2.fullStream) {
-      if (chunk.type === `text-delta`) {
-        chunks2.push(chunk.text);
-      }
-    }
-    const response2 = chunks2.join('');
-    expect(chunks2.length).toBeGreaterThan(0);
-    expect(response2).toContain('Seattle');
-    expect(response2).toContain('70 degrees');
-  });
-  it('should use custom mastra ID generator for messages in memory', async () => {
-    const agent = new Agent({
-      name: 'test-msg-id',
-      instructions: 'you are a helpful assistant.',
-      model: openai('gpt-4o'),
-      memory,
-    });
-    const threadId = randomUUID();
-    const resourceId = 'test-resource-msg-id';
-    const customIds: UUID[] = [];
-    new Mastra({
-      idGenerator: () => {
-        const id = randomUUID();
-        customIds.push(id);
-        return id;
-      },
-      agents: {
-        agent: agent,
-      },
-    });
-    await agent.generateVNext('Hello, world!', {
-      threadId,
-      resourceId,
-    });
-    const agentMemory = (await agent.getMemory())!;
-    const { messages } = await agentMemory.query({ threadId });
-    console.log('Custom IDs: ', customIds);
-    console.log('Messages: ', messages);
-    expect(messages).toHaveLength(2);
-    expect(messages.length).toBeLessThan(customIds.length);
-    for (const message of messages) {
-      if (!(`id` in message)) {
-        throw new Error(`Expected message.id`);
-      }
-      expect(customIds).contains(message.id);
-    }
-  });
-  describe('should stream via useChat after tool call', () => {
-    let mastraServer: ReturnType<typeof spawn>;
-    let port: number;
-    const threadId = randomUUID();
-    const resourceId = 'test-resource';
-    beforeAll(async () => {
-      port = await getAvailablePort();
-      mastraServer = spawn(
-        'pnpm',
-        [
-          path.resolve(import.meta.dirname, `..`, `..`, `..`, `cli`, `dist`, `index.js`),
-          'dev',
-          '--port',
-          port.toString(),
-        ],
-        {
-          stdio: 'pipe',
-          detached: true, // Run in a new process group so we can kill it and children
-        },
-      );
-      // Wait for server to be ready
-      await new Promise<void>((resolve, reject) => {
-        let output = '';
-        mastraServer.stdout?.on('data', data => {
-          output += data.toString();
-          console.log(output);
-          if (output.includes('http://localhost:')) {
-            resolve();
-          }
-        });
-        mastraServer.stderr?.on('data', data => {
-          console.error('Mastra server error:', data.toString());
-        });
-        setTimeout(() => reject(new Error('Mastra server failed to start')), 100000);
-      });
-    });
-    afterAll(() => {
-      // Kill the server and its process group
-      if (mastraServer?.pid) {
-        try {
-          process.kill(-mastraServer.pid, 'SIGTERM');
-        } catch (e) {
-          console.error('Failed to kill Mastra server:', e);
-        }
-      }
-    });
-    it('should stream via useChat after tool call', async () => {
-      let error: Error | null = null;
-      const { result } = renderHook(() => {
-        const chat = useChat({
-          transport: new DefaultChatTransport({
-            api: `http://localhost:${port}/api/agents/test/stream/vnext/ui`,
-            prepareSendMessagesRequest({ messages }) {
-              return {
-                body: {
-                  messages: [messages.at(-1)],
-                  threadId,
-                  resourceId,
-                },
-              };
-            },
-          }),
-          onFinish(message) {
-            console.log('useChat finished', message);
-          },
-          onError(e) {
-            error = e;
-            console.error('useChat error:', error);
-          },
-        });
-        return chat;
-      });
-      let messageCount = 0;
-      async function expectResponse({ message, responseContains }: { message: string; responseContains: string[] }) {
-        messageCount++;
-        await act(async () => {
-          await result.current.sendMessage({
-            role: 'user',
-            parts: [{ type: 'text', text: message }],
-          });
-        });
-        const responseIndex = messageCount * 2 - 1;
-        await waitFor(
-          () => {
-            expect(error).toBeNull();
-            expect(result.current.messages).toHaveLength(messageCount * 2);
-            for (const should of responseContains) {
-              expect(
-                result.current.messages[responseIndex].parts.map(p => (`text` in p ? p.text : '')).join(``),
-              ).toContain(should);
-            }
-          },
-          { timeout: 1000 },
-        );
-      }
-      await expectResponse({
-        message: 'what is the weather in Los Angeles?',
-        responseContains: ['Los Angeles', '70'],
-      });
-      await expectResponse({
-        message: 'what is the weather in Seattle?',
-        responseContains: ['Seattle', '70'],
-      });
-    });
-    it('should stream useChat with client side tool calling', async () => {
-      let error: Error | null = null;
-      const threadId = randomUUID();
-      await weatherAgent.generateVNext(`hi`, {
-        threadId,
-        resourceId,
-      });
-      await weatherAgent.generateVNext(`LA weather`, { threadId, resourceId });
-      const agentMemory = (await weatherAgent.getMemory())!;
-      const initialMessages = (await agentMemory.query({ threadId })).uiMessages;
-      const state = { clipboard: '' };
-      const { result } = renderHook(() => {
-        const chat = useChat({
-          transport: new DefaultChatTransport({
-            api: `http://localhost:${port}/api/agents/test/stream/vnext/ui`,
-            prepareSendMessagesRequest({ messages }) {
-              return {
-                body: {
-                  messages: [messages.at(-1)],
-                  threadId,
-                  resourceId,
-                },
-              };
-            },
-          }),
-          messages: initialMessages as UIMessage[],
-          onFinish(message) {
-            console.log('useChat finished', message);
-          },
-          onError(e) {
-            error = e;
-            console.error('useChat error:', error);
-          },
-          onToolCall: async ({ toolCall }) => {
-            console.log(toolCall);
-            if (toolCall.toolName === `clipboard`) {
-              await new Promise(res => setTimeout(res, 10));
-              return state.clipboard as any as void;
-            }
-          },
-        });
-        return chat;
-      });
-      async function expectResponse({ message, responseContains }: { message: string; responseContains: string[] }) {
-        const messageCountBefore = result.current.messages.length;
-        await act(async () => {
-          await result.current.sendMessage({
-            role: 'user',
-            parts: [{ type: 'text', text: message }],
-          });
-        });
-        // Wait for message count to increase
-        await waitFor(
-          () => {
-            expect(error).toBeNull();
-            expect(result.current.messages.length).toBeGreaterThan(messageCountBefore);
-          },
-          { timeout: 2000 },
-        );
-        // Get fresh reference to messages after all waits complete
-        const uiMessages = result.current.messages;
-        const latestMessage = uiMessages.at(-1);
-        if (!latestMessage) throw new Error(`No latest message`);
-        if (
-          latestMessage.role === `assistant` &&
-          latestMessage.parts.length === 2 &&
-          latestMessage.parts[1].type === `tool-clipboard`
-        ) {
-          // client side tool call
-          return;
-        }
-        for (const should of responseContains) {
-          let searchString = latestMessage.parts.map(p => (`text` in p ? p.text : ``)).join(``);
-          for (const part of latestMessage.parts) {
-            if (part.type === `text`) {
-              searchString += `\n${part.text}`;
-            }
-            if (isToolUIPart(part)) {
-              searchString += `\n${JSON.stringify(part)}`;
-            }
-          }
-          expect(searchString).toContain(should);
-        }
-      }
-      state.clipboard = `test 1!`;
-      await expectResponse({
-        message: 'whats in my clipboard?',
-        responseContains: [state.clipboard],
-      });
-      await expectResponse({
-        message: 'weather in Las Vegas',
-        responseContains: ['Las Vegas', '70'],
-      });
-      state.clipboard = `test 2!`;
-      await expectResponse({
-        message: 'whats in my clipboard?',
-        responseContains: [state.clipboard],
-      });
-      state.clipboard = `test 3!`;
-      await expectResponse({
-        message: 'whats in my clipboard now?',
-        responseContains: [state.clipboard],
-      });
-    });
-  });
-});

package/integration-tests-v5/src/test-utils.ts DELETED Viewed

@@ -1,147 +0,0 @@
-import { MessageList } from '@mastra/core/agent';
-import type { MastraMessageV2 } from '@mastra/core/agent';
-import type { CoreMessage } from '@mastra/core/llm';
-import type { MastraMessageV1 } from '@mastra/core/memory';
-const toolArgs = {
-  weather: { location: 'New York' },
-  calculator: { expression: '2+2' },
-  search: { query: 'latest AI developments' },
-};
-const toolResults = {
-  weather: 'Pretty hot',
-  calculator: '4',
-  search: 'Anthropic blah blah blah',
-};
-/**
- * Creates a simulated conversation history with alternating messages and occasional tool calls
- * @param threadId Thread ID for the messages
- * @param messageCount Number of turn pairs (user + assistant) to generate
- * @param toolFrequency How often to include tool calls (e.g., 3 means every 3rd assistant message)
- * @returns Array of messages representing the conversation
- */
-export function generateConversationHistory({
-  threadId,
-  resourceId = 'test-resource',
-  messageCount = 5,
-  toolFrequency = 3,
-  toolNames = ['weather', 'calculator', 'search'],
-}: {
-  threadId: string;
-  resourceId?: string;
-  messageCount?: number;
-  toolFrequency?: number;
-  toolNames?: (keyof typeof toolArgs)[];
-}): {
-  messages: MastraMessageV1[];
-  messagesV2: MastraMessageV2[];
-  fakeCore: CoreMessage[];
-  counts: { messages: number; toolCalls: number; toolResults: number };
-} {
-  const counts = { messages: 0, toolCalls: 0, toolResults: 0 };
-  // Create some words that will each be about one token
-  const words = ['apple', 'banana', 'orange', 'grape'];
-  // Arguments for different tools
-  const messages: MastraMessageV2[] = [];
-  const startTime = Date.now();
-  // Generate message pairs (user message followed by assistant response)
-  for (let i = 0; i < messageCount; i++) {
-    // Create user message content
-    const userContent = Array(25).fill(words).flat().join(' '); // ~100 tokens
-    // Add user message
-    messages.push({
-      role: 'user',
-      content: { format: 2, parts: [{ type: 'text', text: userContent }] },
-      id: `message-${i * 2}`,
-      threadId,
-      resourceId,
-      createdAt: new Date(startTime + i * 2000), // Each pair 2 seconds apart
-    });
-    counts.messages++;
-    // Determine if this assistant message should include a tool call
-    const includeTool = i > 0 && i % toolFrequency === 0;
-    const toolIndex = includeTool ? (i / toolFrequency) % toolNames.length : -1;
-    const toolName = includeTool ? toolNames[toolIndex] : '';
-    // Create assistant message
-    if (includeTool) {
-      // Assistant message with tool call
-      messages.push({
-        role: 'assistant',
-        content: {
-          format: 2,
-          parts: [
-            { type: 'text', text: `Using ${toolName} tool:` },
-            {
-              type: 'tool-invocation',
-              toolInvocation: {
-                state: 'result',
-                toolCallId: `tool-${i}`,
-                toolName,
-                args: toolArgs[toolName as keyof typeof toolArgs] || {},
-                result: toolResults[toolName as keyof typeof toolResults] || {},
-              },
-            },
-          ],
-        },
-        id: `tool-call-${i * 2 + 1}`,
-        threadId,
-        resourceId,
-        createdAt: new Date(startTime + i * 2000 + 1000), // 1 second after user message
-      });
-      counts.messages++;
-      counts.toolCalls++;
-      counts.toolResults++;
-    } else {
-      // Regular assistant text message
-      messages.push({
-        role: 'assistant',
-        content: { format: 2, parts: [{ type: 'text', text: Array(15).fill(words).flat().join(' ') }] }, // ~60 tokens
-        id: `message-${i * 2 + 1}`,
-        threadId,
-        resourceId,
-        createdAt: new Date(startTime + i * 2000 + 1000), // 1 second after user message
-      });
-      counts.messages++;
-    }
-  }
-  const latestMessage = messages.at(-1)!;
-  if (latestMessage.role === `assistant` && latestMessage.content.parts.at(-1)?.type === `tool-invocation`) {
-    const userContent = Array(25).fill(words).flat().join(' '); // ~100 tokens
-    messages.push({
-      role: 'user',
-      content: { format: 2, parts: [{ type: 'text', text: userContent }] },
-      id: `message-${messages.length + 1 * 2}`,
-      threadId,
-      resourceId,
-      createdAt: new Date(startTime + messages.length + 1 * 2000), // Each pair 2 seconds apart
-    });
-    counts.messages++;
-  }
-  const list = new MessageList().add(messages, 'memory');
-  return {
-    fakeCore: list.get.all.v1() as CoreMessage[],
-    messages: list.get.all.v1(),
-    messagesV2: list.get.all.v2(),
-    counts,
-  };
-}
-export function filterToolCallsByName(messages: CoreMessage[], name: string) {
-  return messages.filter(
-    m => Array.isArray(m.content) && m.content.some(part => part.type === 'tool-call' && part.toolName === name),
-  );
-}
-export function filterToolResultsByName(messages: CoreMessage[], name: string) {
-  return messages.filter(
-    m => Array.isArray(m.content) && m.content.some(part => part.type === 'tool-result' && part.toolName === name),
-  );
-}