@mastra/core 0.5.0-alpha.1 → 0.5.0-alpha.10

package/dist/agent/index.cjs

@@ -1,17 +1,19 @@
 'use strict';
 
 var crypto$1 = require('crypto');
-var zod = require('zod');
 var stream = require('stream');
 var pino = require('pino');
 var pretty = require('pino-pretty');
 var ai = require('ai');
+var zod = require('zod');
+var jsonSchemaToZod = require('json-schema-to-zod');
 var api = require('@opentelemetry/api');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var pino__default = /*#__PURE__*/_interopDefault(pino);
 var pretty__default = /*#__PURE__*/_interopDefault(pretty);
+var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -74,7 +76,14 @@ var Logger = class {
     const transportsAry = Object.entries(this.transports);
     this.logger = pino__default.default({
       name: options.name || "app",
-      level: options.level || LogLevel.INFO
+      level: options.level || LogLevel.INFO,
+      formatters: {
+        level: label => {
+          return {
+            level: label
+          };
+        }
+      }
     }, options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
       colorize: true,
       levelFirst: true,
@@ -354,7 +363,193 @@ var MastraLLMBase = class extends MastraBase {
     throw new Error("Method not implemented.");
   }
 };
+
+// src/tools/tool.ts
+var Tool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  mastra;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+    this.mastra = opts.mastra;
+  }
+};
+
+// src/utils.ts
 var delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+function resolveSerializedZodOutput(schema) {
+  return Function("z", `"use strict";return (${schema});`)(zod.z);
+}
+function isVercelTool(tool) {
+  return !(tool instanceof Tool);
+}
+function createLogMessageOptions({
+  agentName,
+  toolName,
+  tool,
+  type
+}) {
+  if (!agentName) {
+    return {
+      start: `Executing tool ${toolName}`,
+      error: `Failed tool execution`
+    };
+  }
+  const prefix = `[Agent:${agentName}]`;
+  const vercelPrefix = isVercelTool(tool) ? "Vercel " : "";
+  const toolType = type === "toolset" ? "toolset" : "tool";
+  return {
+    start: `${prefix} - Executing ${vercelPrefix}${toolType} ${toolName}`,
+    error: `${prefix} - Failed ${vercelPrefix}${toolType} execution`
+  };
+}
+function createExecute(tool, options, logType) {
+  const {
+    logger,
+    ...rest
+  } = options;
+  const {
+    start,
+    error
+  } = createLogMessageOptions({
+    agentName: options.agentName,
+    toolName: options.name,
+    tool,
+    type: logType
+  });
+  const execFunction = async (args, execOptions) => {
+    if (isVercelTool(tool)) {
+      return tool?.execute?.(args, execOptions) ?? void 0;
+    }
+    return tool?.execute?.({
+      context: args,
+      threadId: options.threadId,
+      resourceId: options.resourceId,
+      mastra: options.mastra,
+      memory: options.memory,
+      runId: options.runId
+    }, execOptions) ?? void 0;
+  };
+  return async (args, execOptions) => {
+    try {
+      logger.debug(start, {
+        ...rest,
+        args
+      });
+      return await execFunction(args, execOptions);
+    } catch (err) {
+      logger.error(error, {
+        ...rest,
+        error: err,
+        args
+      });
+      throw err;
+    }
+  };
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function createDeterministicId(input) {
+  return crypto$1.createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function setVercelToolProperties(tool) {
+  const inputSchema = convertVercelToolParameters(tool);
+  const toolId = !("id" in tool) ? tool.description ? `tool-${createDeterministicId(tool.description)}` : `tool-${Math.random().toString(36).substring(2, 9)}` : tool.id;
+  return {
+    ...tool,
+    id: toolId,
+    inputSchema
+  };
+}
+function ensureToolProperties(tools) {
+  const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
+    const tool = tools?.[key];
+    if (tool) {
+      if (isVercelTool(tool)) {
+        acc[key] = setVercelToolProperties(tool);
+      } else {
+        acc[key] = tool;
+      }
+    }
+    return acc;
+  }, {});
+  return toolsWithProperties;
+}
+function convertVercelToolParameters(tool) {
+  const schema = tool.parameters ?? zod.z.object({});
+  return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod__default.default(schema));
+}
+function makeCoreTool(tool, options, logType) {
+  const getParameters = () => {
+    if (isVercelTool(tool)) {
+      return convertVercelToolParameters(tool);
+    }
+    return tool.inputSchema ?? zod.z.object({});
+  };
+  return {
+    description: tool.description,
+    parameters: getParameters(),
+    execute: tool.execute ? createExecute(tool, {
+      ...options,
+      description: tool.description
+    }, logType) : void 0
+  };
+}
+function createMastraProxy({
+  mastra,
+  logger
+}) {
+  return new Proxy(mastra, {
+    get(target, prop) {
+      const hasProp = Reflect.has(target, prop);
+      if (hasProp) {
+        const value = Reflect.get(target, prop);
+        const isFunction = typeof value === "function";
+        if (isFunction) {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (prop === "logger") {
+        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
+        return Reflect.apply(target.getLogger, target, []);
+      }
+      if (prop === "telemetry") {
+        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
+        return Reflect.apply(target.getTelemetry, target, []);
+      }
+      if (prop === "storage") {
+        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
+        return Reflect.get(target, "storage");
+      }
+      if (prop === "agents") {
+        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
+        return Reflect.apply(target.getAgents, target, []);
+      }
+      if (prop === "tts") {
+        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
+        return Reflect.apply(target.getTTS, target, []);
+      }
+      if (prop === "vectors") {
+        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
+        return Reflect.apply(target.getVectors, target, []);
+      }
+      if (prop === "memory") {
+        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
+        return Reflect.get(target, "memory");
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+}
 
 // src/llm/model/model.ts
 var MastraLLM = class extends MastraLLMBase {
@@ -406,36 +601,16 @@ var MastraLLM = class extends MastraLLMBase {
       const k = value[0];
       const tool = value[1];
       if (tool) {
-        memo[k] = {
-          description: tool.description,
-          parameters: tool.inputSchema,
-          execute: typeof tool?.execute === "function" ? async (props, options) => {
-            try {
-              this.logger.debug("Executing tool", {
-                tool: k,
-                props
-              });
-              return tool?.execute?.({
-                context: props,
-                threadId,
-                resourceId,
-                mastra: this.#mastra,
-                memory,
-                runId
-              }, options) ?? void 0;
-            } catch (error) {
-              this.logger.error("Error executing tool", {
-                tool: k,
-                props,
-                error,
-                runId,
-                threadId,
-                resourceId
-              });
-              throw error;
-            }
-          } : void 0
+        const options = {
+          name: k,
+          runId,
+          threadId,
+          resourceId,
+          logger: this.logger,
+          memory,
+          mastra: this.#mastra
         };
+        memo[k] = makeCoreTool(tool, options);
       }
       return memo;
     }, {});
@@ -1021,10 +1196,13 @@ exports.Agent = class Agent extends (_a = MastraBase) {
     this.metrics = {};
     this.evals = {};
     if (config.tools) {
-      this.tools = config.tools;
+      this.tools = ensureToolProperties(config.tools);
     }
     if (config.mastra) {
-      this.#mastra = config.mastra;
+      this.__registerPrimitives({
+        telemetry: config.mastra.getTelemetry(),
+        logger: config.mastra.getLogger()
+      });
     }
     if (config.metrics) {
       this.logger.warn("The metrics property is deprecated. Please use evals instead to add evaluation metrics.");
@@ -1062,12 +1240,14 @@ exports.Agent = class Agent extends (_a = MastraBase) {
       this.__setLogger(p.logger);
     }
     this.llm.__registerPrimitives(p);
-    this.#mastra = p;
     this.logger.debug(`[Agents:${this.name}] initialized.`, {
       model: this.model,
       name: this.name
     });
   }
+  __registerMastra(mastra) {
+    this.#mastra = mastra;
+  }
   /**
    * Set the concrete tools for the agent
    * @param tools
@@ -1083,8 +1263,8 @@ exports.Agent = class Agent extends (_a = MastraBase) {
     message
   }) {
     const {
-      object
-    } = await this.llm.__textObject({
+      text
+    } = await this.llm.__text({
       messages: [{
         role: "system",
         content: `
@@ -1092,23 +1272,22 @@ exports.Agent = class Agent extends (_a = MastraBase) {
       - you will generate a short title based on the first message a user begins a conversation with
       - ensure it is not more than 80 characters long
       - the title should be a summary of the user's message
-      - do not use quotes or colons`
+      - do not use quotes or colons
+      - the entire text you return will be used as the title`
       }, {
         role: "user",
         content: JSON.stringify(message)
-      }],
-      structuredOutput: zod.z.object({
-        title: zod.z.string()
-      })
+      }]
     });
-    return object.title;
+    const cleanedText = text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+    return cleanedText;
   }
   getMostRecentUserMessage(messages) {
     const userMessages = messages.filter(message => message.role === "user");
     return userMessages.at(-1);
   }
   async genTitle(userMessage) {
-    let title = "New Thread";
+    let title = `New Thread ${(/* @__PURE__ */new Date()).toISOString()}`;
     try {
       if (userMessage) {
         title = await this.generateTitleFromUserMessage({
@@ -1130,17 +1309,18 @@ exports.Agent = class Agent extends (_a = MastraBase) {
     const userMessage = this.getMostRecentUserMessage(userMessages);
     const memory = this.getMemory();
     if (memory) {
+      const config = memory.getMergedThreadConfig(memoryConfig);
       let thread;
       if (!threadId) {
         this.logger.debug(`No threadId, creating new thread for agent ${this.name}`, {
           runId: runId || this.name
         });
-        const title = await this.genTitle(userMessage);
+        const title = config?.threads?.generateTitle ? await this.genTitle(userMessage) : void 0;
         thread = await memory.createThread({
           threadId,
           resourceId,
-          title,
-          memoryConfig
+          memoryConfig,
+          title
         });
       } else {
         thread = await memory.getThreadById({
@@ -1150,7 +1330,7 @@ exports.Agent = class Agent extends (_a = MastraBase) {
           this.logger.debug(`Thread with id ${threadId} not found, creating new thread for agent ${this.name}`, {
             runId: runId || this.name
           });
-          const title = await this.genTitle(userMessage);
+          const title = config?.threads?.generateTitle ? await this.genTitle(userMessage) : void 0;
           thread = await memory.createThread({
             threadId,
             resourceId,
@@ -1174,6 +1354,7 @@ exports.Agent = class Agent extends (_a = MastraBase) {
         });
         const memoryMessages = threadId && memory ? (await memory.rememberMessages({
           threadId,
+          resourceId,
           config: memoryConfig,
           vectorMessageSearch: messages.slice(-1).map(m => {
             if (typeof m === `string`) {
@@ -1293,6 +1474,7 @@ exports.Agent = class Agent extends (_a = MastraBase) {
     let toolResultIds = [];
     let toolCallIds = [];
     for (const message of messages) {
+      if (!Array.isArray(message.content)) continue;
       if (message.role === "tool") {
         for (const content of message.content) {
           if (content.type === "tool-result") {
@@ -1311,7 +1493,9 @@ exports.Agent = class Agent extends (_a = MastraBase) {
     }
     const messagesBySanitizedContent = messages.map(message => {
       if (message.role !== "assistant" && message.role !== `tool` && message.role !== `user`) return message;
-      if (typeof message.content === "string") return message;
+      if (!message.content || typeof message.content === "string" || typeof message.content === "number") {
+        return message;
+      }
       const sanitizedContent = message.content.filter(content => {
         if (content.type === `tool-call`) {
           return toolResultIds.includes(content.toolCallId);
@@ -1356,43 +1540,30 @@ exports.Agent = class Agent extends (_a = MastraBase) {
       resourceId
     });
     const memory = this.getMemory();
-    const memoryTools = memory?.getTools();
+    const memoryTools = memory?.getTools?.();
+    let mastraProxy = void 0;
+    const logger = this.logger;
+    if (this.#mastra) {
+      mastraProxy = createMastraProxy({
+        mastra: this.#mastra,
+        logger
+      });
+    }
     const converted = Object.entries(this.tools || {}).reduce((memo, value) => {
       const k = value[0];
       const tool = this.tools[k];
       if (tool) {
-        memo[k] = {
-          description: tool.description,
-          parameters: tool.inputSchema,
-          execute: typeof tool?.execute === "function" ? async (args, options) => {
-            try {
-              this.logger.debug(`[Agent:${this.name}] - Executing tool ${k}`, {
-                name: k,
-                description: tool.description,
-                args,
-                runId,
-                threadId,
-                resourceId
-              });
-              return tool?.execute?.({
-                context: args,
-                mastra: this.#mastra,
-                memory,
-                runId,
-                threadId,
-                resourceId
-              }, options) ?? void 0;
-            } catch (err) {
-              this.logger.error(`[Agent:${this.name}] - Failed execution`, {
-                error: err,
-                runId,
-                threadId,
-                resourceId
-              });
-              throw err;
-            }
-          } : void 0
+        const options = {
+          name: k,
+          runId,
+          threadId,
+          resourceId,
+          logger: this.logger,
+          mastra: mastraProxy,
+          memory,
+          agentName: this.name
         };
+        memo[k] = makeCoreTool(tool, options);
       }
       return memo;
     }, {});
@@ -1412,7 +1583,7 @@ exports.Agent = class Agent extends (_a = MastraBase) {
             });
             return tool?.execute?.({
               context: args,
-              mastra: this.#mastra,
+              mastra: mastraProxy,
               memory,
               runId,
               threadId,
@@ -1443,36 +1614,15 @@ exports.Agent = class Agent extends (_a = MastraBase) {
       toolsFromToolsets.forEach(toolset => {
         Object.entries(toolset).forEach(([toolName, tool]) => {
           const toolObj = tool;
-          toolsFromToolsetsConverted[toolName] = {
-            description: toolObj.description || "",
-            parameters: toolObj.inputSchema,
-            execute: typeof toolObj?.execute === "function" ? async (args, options) => {
-              try {
-                this.logger.debug(`[Agent:${this.name}] - Executing tool ${toolName}`, {
-                  name: toolName,
-                  description: toolObj.description,
-                  args,
-                  runId,
-                  threadId,
-                  resourceId
-                });
-                return toolObj?.execute?.({
-                  context: args,
-                  runId,
-                  threadId,
-                  resourceId
-                }, options) ?? void 0;
-              } catch (error) {
-                this.logger.error(`[Agent:${this.name}] - Failed toolset execution`, {
-                  error,
-                  runId,
-                  threadId,
-                  resourceId
-                });
-                throw error;
-              }
-            } : void 0
+          const options = {
+            name: toolName,
+            runId,
+            threadId,
+            resourceId,
+            logger: this.logger,
+            agentName: this.name
           };
+          toolsFromToolsetsConverted[toolName] = makeCoreTool(toolObj, options, "toolset");
         });
       });
     }

package/dist/agent/index.d.cts

@@ -1,16 +1,18 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent, n as AgentConfig, ao as AgentGenerateOptions, ap as AgentStreamOptions, an as ToolsInput, am as ToolsetsInput } from '../base-C_bOLlEO.cjs';
-import '../base-hs9NDAZ2.cjs';
-import '../types-m9RryK9a.cjs';
+export { A as Agent, l as AgentConfig, aw as AgentGenerateOptions, ax as AgentStreamOptions, a as ToolsInput, av as ToolsetsInput } from '../base-DLJ5WisC.cjs';
+import '../base-DboIg_Cd.cjs';
+import '../types-CwTG2XyQ.cjs';
 import '../voice/index.cjs';
 import 'sift';
-import '../vector/index.cjs';
-import '../vector/filter/index.cjs';
-import '@opentelemetry/api';
 import '../index-mKY1XrpK.cjs';
 import 'stream';
 import 'pino';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import '@opentelemetry/api';
 import '@opentelemetry/sdk-trace-base';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
 import '../tts/index.cjs';

package/dist/agent/index.d.ts

@@ -1,16 +1,18 @@
 export { Message as AiMessageType } from 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent, n as AgentConfig, ao as AgentGenerateOptions, ap as AgentStreamOptions, an as ToolsInput, am as ToolsetsInput } from '../base-42kpYoR1.js';
-import '../base-D90KQ4XI.js';
-import '../types-m9RryK9a.js';
+export { A as Agent, l as AgentConfig, aw as AgentGenerateOptions, ax as AgentStreamOptions, a as ToolsInput, av as ToolsetsInput } from '../base-mFfX31Ho.js';
+import '../base-BZViaFTt.js';
+import '../types-CwTG2XyQ.js';
 import '../voice/index.js';
 import 'sift';
-import '../vector/index.js';
-import '../vector/filter/index.js';
-import '@opentelemetry/api';
 import '../index-mKY1XrpK.js';
 import 'stream';
 import 'pino';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import '@opentelemetry/api';
 import '@opentelemetry/sdk-trace-base';
+import '../vector/index.js';
+import '../vector/filter/index.js';
 import '../tts/index.js';

package/dist/agent/index.js

@@ -1 +1 @@
-export { Agent } from '../chunk-NWPCPTB7.js';
+export { Agent } from '../chunk-TWAIC2XA.js';

package/dist/{base-D90KQ4XI.d.ts → base-BZViaFTt.d.ts}

@@ -38,6 +38,8 @@ type OtelConfig = {
     export?: {
         /** Export to an OTLP (OpenTelemetry Protocol) endpoint */
         type: 'otlp';
+        /** Whether to use gRPC or HTTP for OTLP */
+        protocol?: 'grpc' | 'http';
         /** OTLP endpoint URL */
         endpoint?: string;
         /** Optional headers for OTLP requests */