@mastra/core 0.9.5-alpha.0 → 0.10.0

package/dist/chunk-ZZDAC5KD.cjs

@@ -0,0 +1,325 @@
+'use strict';
+
+var chunk5HULBQ2W_cjs = require('./chunk-5HULBQ2W.cjs');
+var chunkU3L3NEOM_cjs = require('./chunk-U3L3NEOM.cjs');
+var chunkYEULQPUY_cjs = require('./chunk-YEULQPUY.cjs');
+
+// src/memory/memory.ts
+var MemoryProcessor = class extends chunkYEULQPUY_cjs.MastraBase {
+  /**
+   * Process a list of messages and return a filtered or transformed list.
+   * @param messages The messages to process
+   * @returns The processed messages
+   */
+  process(messages, _opts) {
+    return messages;
+  }
+};
+var memoryDefaultOptions = {
+  lastMessages: 10,
+  semanticRecall: false,
+  threads: {
+    generateTitle: false
+  },
+  workingMemory: {
+    enabled: false,
+    template: `
+# User Information
+- **First Name**: 
+- **Last Name**: 
+- **Location**: 
+- **Occupation**: 
+- **Interests**: 
+- **Goals**: 
+- **Events**: 
+- **Facts**: 
+- **Projects**: 
+`
+  }
+};
+var MastraMemory = class extends chunkYEULQPUY_cjs.MastraBase {
+  MAX_CONTEXT_TOKENS;
+  _storage;
+  vector;
+  embedder;
+  processors = [];
+  threadConfig = { ...memoryDefaultOptions };
+  constructor(config) {
+    super({ component: "MEMORY", name: config.name });
+    if (config.options) this.threadConfig = this.getMergedThreadConfig(config.options);
+    if (config.processors) this.processors = config.processors;
+    if (config.storage) {
+      this._storage = chunk5HULBQ2W_cjs.augmentWithInit(config.storage);
+      this._hasOwnStorage = true;
+    }
+    if (this.threadConfig.semanticRecall) {
+      if (!config.vector) {
+        throw new Error(
+          `Semantic recall requires a vector store to be configured.
+
+https://mastra.ai/en/docs/memory/semantic-recall`
+        );
+      }
+      this.vector = config.vector;
+      if (!config.embedder) {
+        throw new Error(
+          `Semantic recall requires an embedder to be configured.
+
+https://mastra.ai/en/docs/memory/semantic-recall`
+        );
+      }
+      this.embedder = config.embedder;
+    }
+  }
+  _hasOwnStorage = false;
+  get hasOwnStorage() {
+    return this._hasOwnStorage;
+  }
+  get storage() {
+    if (!this._storage) {
+      throw new Error(
+        `Memory requires a storage provider to function. Add a storage configuration to Memory or to your Mastra instance.
+
+https://mastra.ai/en/docs/memory/overview`
+      );
+    }
+    return this._storage;
+  }
+  setStorage(storage) {
+    this._storage = storage;
+  }
+  setVector(vector) {
+    this.vector = vector;
+  }
+  setEmbedder(embedder) {
+    this.embedder = embedder;
+  }
+  /**
+   * Get a system message to inject into the conversation.
+   * This will be called before each conversation turn.
+   * Implementations can override this to inject custom system messages.
+   */
+  async getSystemMessage(_input) {
+    return null;
+  }
+  /**
+   * Get tools that should be available to the agent.
+   * This will be called when converting tools for the agent.
+   * Implementations can override this to provide additional tools.
+   */
+  getTools(_config) {
+    return {};
+  }
+  async createEmbeddingIndex(dimensions) {
+    const defaultDimensions = 1536;
+    const isDefault = dimensions === defaultDimensions;
+    const usedDimensions = dimensions ?? defaultDimensions;
+    const separator = this.vector?.indexSeparator ?? "_";
+    const indexName = isDefault ? `memory${separator}messages` : `memory${separator}messages${separator}${usedDimensions}`;
+    if (typeof this.vector === `undefined`) {
+      throw new Error(`Tried to create embedding index but no vector db is attached to this Memory instance.`);
+    }
+    await this.vector.createIndex({
+      indexName,
+      dimension: usedDimensions
+    });
+    return { indexName };
+  }
+  getMergedThreadConfig(config) {
+    if (config?.workingMemory && "use" in config.workingMemory) {
+      throw new Error("The workingMemory.use option has been removed. Working memory always uses tool-call mode.");
+    }
+    return chunkU3L3NEOM_cjs.deepMerge(this.threadConfig, config || {});
+  }
+  /**
+   * Apply all configured message processors to a list of messages.
+   * @param messages The messages to process
+   * @returns The processed messages
+   */
+  applyProcessors(messages, opts) {
+    const processors = opts.processors || this.processors;
+    if (!processors || processors.length === 0) {
+      return messages;
+    }
+    let processedMessages = [...messages];
+    for (const processor of processors) {
+      processedMessages = processor.process(processedMessages, {
+        systemMessage: opts.systemMessage,
+        newMessages: opts.newMessages,
+        memorySystemMessage: opts.memorySystemMessage
+      });
+    }
+    return processedMessages;
+  }
+  processMessages({
+    messages,
+    processors,
+    ...opts
+  }) {
+    return this.applyProcessors(messages, { processors: processors || this.processors, ...opts });
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.split(" ").length * 1.3);
+  }
+  parseMessages(messages) {
+    return messages.map((msg) => {
+      let content = msg.content;
+      if (typeof content === "string" && (content.startsWith("[") || content.startsWith("{"))) {
+        try {
+          content = JSON.parse(content);
+        } catch {
+        }
+      } else if (typeof content === "number") {
+        content = String(content);
+      }
+      return {
+        ...msg,
+        content
+      };
+    });
+  }
+  convertToUIMessages(messages) {
+    function addToolMessageToChat({
+      toolMessage,
+      messages: messages2,
+      toolResultContents
+    }) {
+      const chatMessages2 = messages2.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;
+      });
+      const resultContents = [...toolResultContents, ...toolMessage.content];
+      return { chatMessages: chatMessages2, toolResultContents: resultContents };
+    }
+    const { chatMessages } = messages.reduce(
+      (obj, message) => {
+        if (message.role === "tool") {
+          return addToolMessageToChat({
+            toolMessage: message,
+            messages: obj.chatMessages,
+            toolResultContents: obj.toolResultContents
+          });
+        }
+        let textContent = "";
+        let toolInvocations = [];
+        if (typeof message.content === "string") {
+          textContent = message.content;
+        } else if (typeof message.content === "number") {
+          textContent = String(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,
+          content: textContent,
+          toolInvocations,
+          createdAt: message.createdAt
+        });
+        return obj;
+      },
+      { chatMessages: [], toolResultContents: [] }
+    );
+    return chatMessages;
+  }
+  /**
+   * Helper method to create a new thread
+   * @param title - Optional title for the thread
+   * @param metadata - Optional metadata for the thread
+   * @returns Promise resolving to the created thread
+   */
+  async createThread({
+    threadId,
+    resourceId,
+    title,
+    metadata,
+    memoryConfig
+  }) {
+    await this.storage.init();
+    const thread = {
+      id: threadId || this.generateId(),
+      title: title || `New Thread ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      resourceId,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      metadata
+    };
+    return this.saveThread({ thread, memoryConfig });
+  }
+  /**
+   * Helper method to add a single message to a thread
+   * @param threadId - The thread to add the message to
+   * @param content - The message content
+   * @param role - The role of the message sender
+   * @param type - The type of the message
+   * @param toolNames - Optional array of tool names that were called
+   * @param toolCallArgs - Optional array of tool call arguments
+   * @param toolCallIds - Optional array of tool call ids
+   * @returns Promise resolving to the saved message
+   */
+  async addMessage({
+    threadId,
+    resourceId,
+    config,
+    content,
+    role,
+    type,
+    toolNames,
+    toolCallArgs,
+    toolCallIds
+  }) {
+    const message = {
+      id: this.generateId(),
+      content,
+      role,
+      createdAt: /* @__PURE__ */ new Date(),
+      threadId,
+      resourceId,
+      type,
+      toolNames,
+      toolCallArgs,
+      toolCallIds
+    };
+    const savedMessages = await this.saveMessages({ messages: [message], memoryConfig: config });
+    return savedMessages[0];
+  }
+  /**
+   * Generates a unique identifier
+   * @returns A unique string ID
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+};
+
+exports.MastraMemory = MastraMemory;
+exports.MemoryProcessor = MemoryProcessor;
+exports.memoryDefaultOptions = memoryDefaultOptions;

package/dist/deployer/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkE4FAXBUV_cjs = require('../chunk-E4FAXBUV.cjs');
+var chunkCWSFP2HS_cjs = require('../chunk-CWSFP2HS.cjs');
 
 
 
 Object.defineProperty(exports, "MastraDeployer", {
   enumerable: true,
-  get: function () { return chunkE4FAXBUV_cjs.MastraDeployer; }
+  get: function () { return chunkCWSFP2HS_cjs.MastraDeployer; }
 });

package/dist/deployer/index.d.cts

@@ -1,9 +1,8 @@
 import { MastraBundler, IBundler } from '../bundler/index.cjs';
-import '../base-H7siSAfu.cjs';
+import '../base-aPYtPBT2.cjs';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.cjs';
+import '../logger-EhZkzZOr.cjs';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 
 interface IDeployer extends IBundler {

package/dist/deployer/index.d.ts

@@ -1,9 +1,8 @@
 import { MastraBundler, IBundler } from '../bundler/index.js';
-import '../base-4Z34GQL8.js';
+import '../base-tc5kgDTD.js';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.js';
+import '../logger-EhZkzZOr.js';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 
 interface IDeployer extends IBundler {

package/dist/deployer/index.js

@@ -1 +1 @@
-export { MastraDeployer } from '../chunk-W4BSLENO.js';
+export { MastraDeployer } from '../chunk-2NTUAUGH.js';

package/dist/eval/index.d.cts

@@ -1,29 +1,28 @@
-import { a as Metric, T as TestInfo, E as EvaluationResult } from '../types-BtMyV38I.cjs';
-export { M as MetricResult } from '../types-BtMyV38I.cjs';
-import { G as Agent } from '../base-BV8SNIdm.cjs';
+import { M as Metric, T as TestInfo, E as EvaluationResult } from '../types-Bo1uigWx.cjs';
+export { a as MetricResult } from '../types-Bo1uigWx.cjs';
+import { r as Agent } from '../base-aJ3etsh5.cjs';
 import 'ai';
-import '../base-H7siSAfu.cjs';
+import '../base-aPYtPBT2.cjs';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.cjs';
+import '../logger-EhZkzZOr.cjs';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 import 'sift';
 import 'zod';
 import 'json-schema';
-import '../runtime-context/index.cjs';
-import 'xstate';
-import 'node:events';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
 import 'node:http';
 import 'hono';
-import '../tts/index.cjs';
+import '../runtime-context/index.cjs';
 import '../vector/index.cjs';
 import '../vector/filter/index.cjs';
-import 'events';
-import '../deployer/index.cjs';
-import '../bundler/index.cjs';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.cjs';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';
 
 declare function evaluate<T extends Agent>({ agentName, input, metric, output, runId, globalRunId, testInfo, instructions, }: {

package/dist/eval/index.d.ts

@@ -1,29 +1,28 @@
-import { a as Metric, T as TestInfo, E as EvaluationResult } from '../types-BtMyV38I.js';
-export { M as MetricResult } from '../types-BtMyV38I.js';
-import { G as Agent } from '../base-CI7Uz2GO.js';
+import { M as Metric, T as TestInfo, E as EvaluationResult } from '../types-Bo1uigWx.js';
+export { a as MetricResult } from '../types-Bo1uigWx.js';
+import { r as Agent } from '../base-DttB7sJD.js';
 import 'ai';
-import '../base-4Z34GQL8.js';
+import '../base-tc5kgDTD.js';
 import '@opentelemetry/api';
-import '../index-QV27jkxQ.js';
+import '../logger-EhZkzZOr.js';
 import 'stream';
-import 'pino';
 import '@opentelemetry/sdk-trace-base';
 import 'sift';
 import 'zod';
 import 'json-schema';
-import '../runtime-context/index.js';
-import 'xstate';
-import 'node:events';
+import '../deployer/index.js';
+import '../bundler/index.js';
 import 'node:http';
 import 'hono';
-import '../tts/index.js';
+import '../runtime-context/index.js';
 import '../vector/index.js';
 import '../vector/filter/index.js';
-import 'events';
-import '../deployer/index.js';
-import '../bundler/index.js';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.js';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';
 
 declare function evaluate<T extends Agent>({ agentName, input, metric, output, runId, globalRunId, testInfo, instructions, }: {

package/dist/hooks/index.d.cts

@@ -1,4 +1,4 @@
-import { M as MetricResult, T as TestInfo, a as Metric } from '../types-BtMyV38I.cjs';
+import { a as MetricResult, T as TestInfo, M as Metric } from '../types-Bo1uigWx.cjs';
 
 type Handler<T = unknown> = (event: T) => void;
 

package/dist/hooks/index.d.ts

@@ -1,4 +1,4 @@
-import { M as MetricResult, T as TestInfo, a as Metric } from '../types-BtMyV38I.js';
+import { a as MetricResult, T as TestInfo, M as Metric } from '../types-Bo1uigWx.js';
 
 type Handler<T = unknown> = (event: T) => void;