@mastra/core 0.2.0-alpha.84 → 0.2.0-alpha.87

package/README.md

@@ -53,7 +53,7 @@ import { embed, EmbeddingOptions } from '@mastra/core';
 
 const embeddings = await embed('text to embed', {
   provider: 'OPEN_AI',
-  model: 'text-embedding-ada-002',
+  model: 'text-embedding-3-small',
 });
 ```
 

package/dist/action/index.d.ts

@@ -1,5 +1,5 @@
 import 'zod';
-export { I as IAction, aR as IExecutionContext, d as MastraPrimitives } from '../index-62DyKJRU.js';
+export { I as IAction, aT as IExecutionContext, d as MastraPrimitives } from '../index-Duqv1Yom.js';
 import '../engine-EwEG-4Iv.js';
 import '../index-B0-NXUYv.js';
 import '../telemetry-oCUM52DG.js';
@@ -14,5 +14,5 @@ import 'stream';
 import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
 import '../metric-D2V4CR8D.js';
-import '../types-M16hSruO.js';
 import 'sift';
+import '../types-M16hSruO.js';

package/dist/agent/index.d.ts

@@ -1,18 +1,18 @@
 import 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent } from '../index-62DyKJRU.js';
+export { A as Agent } from '../index-Duqv1Yom.js';
 import '../base.js';
 import '../metric-D2V4CR8D.js';
-import '../types-M16hSruO.js';
 import '../telemetry-oCUM52DG.js';
-import '@opentelemetry/api';
-import '@opentelemetry/sdk-node';
-import '@opentelemetry/sdk-trace-base';
-import 'sift';
 import '../index-B0-NXUYv.js';
 import 'pino';
 import 'stream';
+import 'sift';
+import '../types-M16hSruO.js';
 import '../vector/index.js';
+import '@opentelemetry/api';
+import '@opentelemetry/sdk-node';
+import '@opentelemetry/sdk-trace-base';
 import '../engine-EwEG-4Iv.js';
 import '../tts/index.js';

package/dist/agent/index.js

@@ -1,4 +1,4 @@
-export { Agent } from '../chunk-SAXFXAKK.js';
+export { Agent } from '../chunk-73XDWPXJ.js';
 import '../chunk-HBTQNIAX.js';
 import '../chunk-SDKEPBBH.js';
 import '../chunk-6WJREZ5F.js';

package/dist/chunk-2ISN3AA7.js

@@ -0,0 +1,392 @@
+import { delay } from './chunk-LUULSM4U.js';
+import { MastraBase } from './chunk-JCRGAEY6.js';
+import { RegisteredLogger } from './chunk-TJK6TGSR.js';
+import { __name, __privateAdd, __privateSet, __privateGet } from './chunk-AJJZUHB4.js';
+import { generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
+import { z } from 'zod';
+
+// src/llm/model/base.ts
+var _mastra;
+var _MastraLLMBase = class _MastraLLMBase extends MastraBase {
+  constructor({ name }) {
+    super({
+      component: RegisteredLogger.LLM,
+      name
+    });
+    // @ts-ignore
+    __privateAdd(this, _mastra);
+  }
+  convertToMessages(messages) {
+    if (Array.isArray(messages)) {
+      return messages.map((m) => {
+        if (typeof m === "string") {
+          return {
+            role: "user",
+            content: m
+          };
+        }
+        return m;
+      });
+    }
+    return [
+      {
+        role: "user",
+        content: messages
+      }
+    ];
+  }
+  __registerPrimitives(p) {
+    if (p.telemetry) {
+      this.__setTelemetry(p.telemetry);
+    }
+    if (p.logger) {
+      this.__setLogger(p.logger);
+    }
+    __privateSet(this, _mastra, p);
+  }
+  async __text(input) {
+    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
+      input
+    });
+    throw new Error("Method not implemented.");
+  }
+  async __textObject(input) {
+    this.logger.debug(`[LLMs:${this.name}] Generating object.`, {
+      input
+    });
+    throw new Error("Method not implemented.");
+  }
+  async generate(messages, options = {}) {
+    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
+      messages,
+      options
+    });
+    throw new Error("Method not implemented.");
+  }
+  async __stream(input) {
+    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
+      input
+    });
+    throw new Error("Method not implemented.");
+  }
+  async __streamObject(input) {
+    this.logger.debug(`[LLMs:${this.name}] Streaming object.`, {
+      input
+    });
+    throw new Error("Method not implemented.");
+  }
+  async stream(messages, options = {}) {
+    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
+      messages,
+      options
+    });
+    throw new Error("Method not implemented.");
+  }
+};
+_mastra = new WeakMap();
+__name(_MastraLLMBase, "MastraLLMBase");
+var MastraLLMBase = _MastraLLMBase;
+
+// src/llm/model/model.ts
+var _model, _mastra2;
+var _MastraLLM = class _MastraLLM extends MastraLLMBase {
+  constructor({ model, mastra }) {
+    super({
+      name: "aisdk"
+    });
+    __privateAdd(this, _model);
+    __privateAdd(this, _mastra2);
+    __privateSet(this, _model, model);
+    if (mastra) {
+      __privateSet(this, _mastra2, mastra);
+      if (mastra.logger) {
+        this.__setLogger(mastra.logger);
+      }
+    }
+  }
+  convertTools(tools) {
+    this.logger.debug("Starting tool conversion for LLM");
+    const converted = Object.entries(tools || {}).reduce((memo, value) => {
+      const k = value[0];
+      const tool = value[1];
+      if (tool) {
+        memo[k] = {
+          description: tool.description,
+          parameters: tool.inputSchema,
+          execute: /* @__PURE__ */ __name(async (props) => {
+            this.logger.debug("Executing tool", {
+              tool: k,
+              props
+            });
+            return tool.execute({
+              context: props,
+              mastra: __privateGet(this, _mastra2)
+            });
+          }, "execute")
+        };
+      }
+      return memo;
+    }, {});
+    this.logger.debug(`Converted tools for LLM`);
+    return converted;
+  }
+  async __text({ runId, messages, maxSteps, tools, convertedTools, temperature, toolChoice = "auto", onStepFinish }) {
+    const model = __privateGet(this, _model);
+    this.logger.debug(`[LLM] - Generating text`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      toolChoice,
+      maxSteps,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
+          this.logger.warn("Rate limit approaching, waiting 10 seconds");
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish")
+    };
+    return await generateText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __textObject({ messages, onStepFinish, maxSteps = 5, tools, convertedTools, structuredOutput, runId, temperature }) {
+    const model = __privateGet(this, _model);
+    this.logger.debug(`[LLM] - Generating a text object`, {
+      runId
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish")
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = jsonSchema(structuredOutput);
+    }
+    return await generateObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __stream({ messages, onStepFinish, onFinish, maxSteps = 5, tools, convertedTools, runId, temperature }) {
+    const model = __privateGet(this, _model);
+    this.logger.debug(`[LLM] - Streaming text`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish"),
+      onFinish: /* @__PURE__ */ __name(async (props) => {
+        onFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+      }, "onFinish")
+    };
+    return await streamText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __streamObject({ messages, onStepFinish, onFinish, maxSteps = 5, tools, convertedTools, structuredOutput, runId, temperature }) {
+    const model = __privateGet(this, _model);
+    this.logger.debug(`[LLM] - Streaming structured output`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish"),
+      onFinish: /* @__PURE__ */ __name(async (props) => {
+        onFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+      }, "onFinish")
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = jsonSchema(structuredOutput);
+    }
+    return streamObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async generate(messages, { maxSteps = 5, onStepFinish, tools, convertedTools, runId, output = "text", temperature } = {}) {
+    const msgs = this.convertToMessages(messages);
+    if (output === "text") {
+      return await this.__text({
+        messages: msgs,
+        onStepFinish,
+        maxSteps,
+        tools,
+        convertedTools,
+        runId,
+        temperature
+      });
+    }
+    return await this.__textObject({
+      messages: msgs,
+      structuredOutput: output,
+      onStepFinish,
+      maxSteps,
+      tools,
+      convertedTools,
+      runId
+    });
+  }
+  async stream(messages, { maxSteps = 5, onFinish, onStepFinish, tools, convertedTools, runId, output = "text", temperature } = {}) {
+    const msgs = this.convertToMessages(messages);
+    if (output === "text") {
+      return await this.__stream({
+        messages: msgs,
+        onStepFinish,
+        onFinish,
+        maxSteps,
+        tools,
+        convertedTools,
+        runId,
+        temperature
+      });
+    }
+    return await this.__streamObject({
+      messages: msgs,
+      structuredOutput: output,
+      onStepFinish,
+      onFinish,
+      maxSteps,
+      tools,
+      convertedTools,
+      runId,
+      temperature
+    });
+  }
+};
+_model = new WeakMap();
+_mastra2 = new WeakMap();
+__name(_MastraLLM, "MastraLLM");
+var MastraLLM = _MastraLLM;
+
+export { MastraLLM };

package/dist/chunk-2J5OHBUG.js

@@ -0,0 +1,24 @@
+import { MastraLLM } from './chunk-2ISN3AA7.js';
+import { __name } from './chunk-AJJZUHB4.js';
+import { createOpenAI } from '@ai-sdk/openai';
+
+var _OpenAI = class _OpenAI extends MastraLLM {
+  constructor({ name, apiKey, headers, fetch, baseURL, settings }) {
+    const openai = createOpenAI({
+      apiKey: apiKey || process.env.OPENAI_API_KEY,
+      baseURL,
+      headers,
+      fetch
+    });
+    super({
+      model: openai(name || "gpt-4o-mini", {
+        structuredOutputs: true,
+        ...settings
+      })
+    });
+  }
+};
+__name(_OpenAI, "OpenAI");
+var OpenAI = _OpenAI;
+
+export { OpenAI };

package/dist/{chunk-Y7TKCKRI.js → chunk-5NQ3MEZM.js}

@@ -8,9 +8,9 @@ import { embed as embed$1, embedMany as embedMany$1 } from 'ai';
 import { createVoyage } from 'voyage-ai-provider';
 import 'dotenv/config';
 
-function getEmbeddingModel(embeddingOptions) {
+function getEmbeddingModel(embedding) {
   let embeddingModel;
-  const { provider, model, apiKey } = embeddingOptions;
+  const { provider, model, apiKey } = embedding;
   if (provider === "OPEN_AI") {
     const openai = createOpenAI({
       apiKey: apiKey || process.env.OPENAI_API_KEY
@@ -53,9 +53,9 @@ function getEmbeddingModel(embeddingOptions) {
   return embeddingModel;
 }
 __name(getEmbeddingModel, "getEmbeddingModel");
-async function embed(value, embeddingOptions) {
-  const embeddingModel = await getEmbeddingModel(embeddingOptions);
-  const { maxRetries } = embeddingOptions;
+async function embed(value, embedding) {
+  const embeddingModel = await getEmbeddingModel(embedding);
+  const { maxRetries } = embedding;
   return await embed$1({
     model: embeddingModel,
     value,
@@ -63,9 +63,9 @@ async function embed(value, embeddingOptions) {
   });
 }
 __name(embed, "embed");
-async function embedMany(value, embeddingOptions) {
-  const embeddingModel = await getEmbeddingModel(embeddingOptions);
-  const { maxRetries } = embeddingOptions;
+async function embedMany(value, embedding) {
+  const embeddingModel = await getEmbeddingModel(embedding);
+  const { maxRetries } = embedding;
   return await embedMany$1({
     model: embeddingModel,
     values: value,

package/dist/{chunk-SAXFXAKK.js → chunk-73XDWPXJ.js}

@@ -26,6 +26,7 @@ var _Agent = class _Agent extends MastraBase {
       component: RegisteredLogger.AGENT
     });
     __publicField(this, "name");
+    // @ts-ignore
     __publicField(this, "llm");
     __publicField(this, "instructions");
     __publicField(this, "model");
@@ -35,10 +36,17 @@ var _Agent = class _Agent extends MastraBase {
     __publicField(this, "metrics");
     this.name = config.name;
     this.instructions = config.instructions;
-    this.llm = new LLM({
-      model: config.model
-    });
-    this.model = config.model;
+    if (!config.model && !config.llm) {
+      throw new Error("Either model or llm is required");
+    }
+    if (config.llm) {
+      this.llm = config.llm;
+    } else if (config.model) {
+      this.model = config.model;
+      this.llm = new LLM({
+        model: config.model
+      });
+    }
     this.tools = {};
     this.metrics = {};
     if (config.tools) {
@@ -244,7 +252,7 @@ var _Agent = class _Agent extends MastraBase {
       messages: userMessages
     };
   }
-  async saveResponse({ result, threadId, runId, memoryConfig }) {
+  async saveResponse({ result, threadId, resourceId, runId, memoryConfig }) {
     const { response } = result;
     try {
       if (response.messages) {
@@ -254,9 +262,11 @@ var _Agent = class _Agent extends MastraBase {
         const responseMessagesWithoutIncompleteToolCalls = this.sanitizeResponseMessages(ms);
         const memory = this.getMemory();
         if (memory) {
-          this.log(LogLevel.DEBUG, "Saving response to memory", {
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence: store=${__privateGet(this, _mastra)?.memory?.constructor.name} threadId=${threadId}`, {
+            runId,
+            resourceId,
             threadId,
-            runId
+            memoryStore: __privateGet(this, _mastra)?.memory?.constructor.name
           });
           await memory.saveMessages({
             memoryConfig,
@@ -415,6 +425,12 @@ var _Agent = class _Agent extends MastraBase {
         let coreMessages = messages;
         let threadIdToUse = threadId;
         if (this.getMemory() && resourceId) {
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${__privateGet(this, _mastra)?.memory?.constructor.name}, resourceId=${resourceId}`, {
+            runId,
+            resourceId,
+            threadId: threadIdToUse,
+            memoryStore: __privateGet(this, _mastra)?.memory?.constructor.name
+          });
           const preExecuteResult = await this.preExecute({
             resourceId,
             runId,
@@ -424,22 +440,31 @@ var _Agent = class _Agent extends MastraBase {
           });
           coreMessages = preExecuteResult.coreMessages;
           threadIdToUse = preExecuteResult.threadIdToUse;
-        } else {
-          this.logger.debug(`[Agents:${this.name}] - No memory store or resourceid identifier found. Skipping memory persistence.`, {
-            runId
-          });
         }
         let convertedTools;
         if (toolsets && Object.keys(toolsets || {}).length > 0 || this.getMemory() && resourceId || __privateGet(this, _mastra)?.engine) {
+          const reasons = [];
+          if (toolsets && Object.keys(toolsets || {}).length > 0) {
+            reasons.push(`toolsets present (${Object.keys(toolsets || {}).length} tools)`);
+          }
+          if (this.getMemory() && resourceId) {
+            reasons.push("memory and resourceId available");
+          }
+          if (__privateGet(this, _mastra)?.engine) {
+            reasons.push("mastra engine enabled");
+          }
+          this.logger.debug(`[Agent:${this.name}] - Enhancing tools: ${reasons.join(", ")}`, {
+            runId,
+            toolsets: toolsets ? Object.keys(toolsets) : undefined,
+            hasMemory: !!this.getMemory(),
+            hasResourceId: !!resourceId,
+            hasEngine: !!__privateGet(this, _mastra)?.engine
+          });
           convertedTools = this.convertTools({
             toolsets,
             threadId: threadIdToUse,
             runId
           });
-        } else {
-          this.logger.debug(`Skipping tool conversion for agent ${this.name}`, {
-            runId
-          });
         }
         const messageObjects = [
           systemMessage,
@@ -477,13 +502,10 @@ var _Agent = class _Agent extends MastraBase {
         });
         if (this.getMemory() && resourceId) {
           try {
-            this.logger.debug(`Saving assistant message in memory for agent ${this.name}`, {
-              runId: runId2,
-              threadId: threadId2
-            });
             await this.saveResponse({
               result,
               threadId: threadId2,
+              resourceId,
               memoryConfig: memoryConfig2,
               runId: runId2
             });
@@ -495,11 +517,6 @@ var _Agent = class _Agent extends MastraBase {
               threadId: threadId2
             });
           }
-        } else {
-          this.logger.debug(`[Agents:${this.name}] - No memory store or resourceid identifier found. Skipping memory persistence.`, {
-            runId: runId2,
-            threadId: threadId2
-          });
         }
         if (Object.keys(this.metrics || {}).length > 0) {
           const input = messages.map((message) => message.content).join("\n");

package/dist/{chunk-3IV6WDJY.js → chunk-D66E7L7R.js}

@@ -1,4 +1,4 @@
-import { Agent } from './chunk-SAXFXAKK.js';
+import { Agent } from './chunk-73XDWPXJ.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 import { CohereClient } from 'cohere-ai';