@mastra/core 0.9.0 → 0.9.1-alpha.1

package/dist/chunk-7AGAXO6B.cjs

@@ -0,0 +1,588 @@
+'use strict';
+
+var chunkYTTBFAQJ_cjs = require('./chunk-YTTBFAQJ.cjs');
+var chunkD63P5O4Q_cjs = require('./chunk-D63P5O4Q.cjs');
+var chunkO7IW545H_cjs = require('./chunk-O7IW545H.cjs');
+var ai = require('ai');
+var zod = require('zod');
+
+// src/llm/model/base.ts
+var MastraLLMBase = class extends chunkD63P5O4Q_cjs.MastraBase {
+  // @ts-ignore
+  #mastra;
+  #model;
+  constructor({ name, model }) {
+    super({
+      component: chunkO7IW545H_cjs.RegisteredLogger.LLM,
+      name
+    });
+    this.#model = model;
+  }
+  getProvider() {
+    return this.#model.provider;
+  }
+  getModelId() {
+    return this.#model.modelId;
+  }
+  getModel() {
+    return this.#model;
+  }
+  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);
+    }
+  }
+  __registerMastra(p) {
+    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.");
+  }
+};
+
+// src/llm/model/model.ts
+var MastraLLM = class extends MastraLLMBase {
+  #model;
+  #mastra;
+  constructor({ model, mastra }) {
+    super({ name: "aisdk", model });
+    this.#model = model;
+    if (mastra) {
+      this.#mastra = mastra;
+      if (mastra.getLogger()) {
+        this.__setLogger(mastra.getLogger());
+      }
+    }
+  }
+  __registerPrimitives(p) {
+    if (p.telemetry) {
+      this.__setTelemetry(p.telemetry);
+    }
+    if (p.logger) {
+      this.__setLogger(p.logger);
+    }
+  }
+  __registerMastra(p) {
+    this.#mastra = p;
+  }
+  getProvider() {
+    return this.#model.provider;
+  }
+  getModelId() {
+    return this.#model.modelId;
+  }
+  getModel() {
+    return this.#model;
+  }
+  convertTools({
+    tools,
+    runId,
+    threadId,
+    resourceId,
+    memory,
+    runtimeContext
+  }) {
+    this.logger.debug("Starting tool conversion for LLM");
+    let mastraProxy = void 0;
+    const logger = this.logger;
+    if (this.#mastra) {
+      mastraProxy = chunkYTTBFAQJ_cjs.createMastraProxy({ mastra: this.#mastra, logger });
+    }
+    const converted = Object.entries(tools || {}).reduce(
+      (memo, value) => {
+        const k = value[0];
+        const tool = value[1];
+        if (tool) {
+          const options = {
+            name: k,
+            runId,
+            threadId,
+            resourceId,
+            logger: this.logger,
+            memory,
+            mastra: mastraProxy,
+            runtimeContext
+          };
+          memo[k] = chunkYTTBFAQJ_cjs.makeCoreTool(tool, options);
+        }
+        return memo;
+      },
+      {}
+    );
+    this.logger.debug(`Converted tools for LLM`);
+    return converted;
+  }
+  async __text({
+    runId,
+    messages,
+    maxSteps = 5,
+    tools,
+    convertedTools,
+    temperature,
+    toolChoice = "auto",
+    onStepFinish,
+    experimental_output,
+    telemetry,
+    threadId,
+    resourceId,
+    memory,
+    runtimeContext,
+    ...rest
+  }) {
+    const model = this.#model;
+    this.logger.debug(`[LLM] - Generating text`, {
+      runId,
+      messages,
+      maxSteps,
+      threadId,
+      resourceId,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools({ tools, runId, threadId, resourceId, memory, runtimeContext });
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      toolChoice,
+      maxSteps,
+      onStepFinish: async (props) => {
+        void onStepFinish?.(props);
+        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 chunkYTTBFAQJ_cjs.delay(10 * 1e3);
+        }
+      },
+      ...rest
+    };
+    let schema;
+    if (experimental_output) {
+      this.logger.debug("[LLM] - Using experimental output", {
+        runId
+      });
+      if (typeof experimental_output.parse === "function") {
+        schema = experimental_output;
+        if (schema instanceof zod.z.ZodArray) {
+          schema = schema._def.type;
+        }
+      } else {
+        schema = ai.jsonSchema(experimental_output);
+      }
+    }
+    return await ai.generateText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: {
+        ...this.experimental_telemetry,
+        ...telemetry
+      },
+      experimental_output: schema ? ai.Output.object({
+        schema
+      }) : void 0
+    });
+  }
+  async __textObject({
+    messages,
+    onStepFinish,
+    maxSteps = 5,
+    tools,
+    convertedTools,
+    structuredOutput,
+    runId,
+    temperature,
+    toolChoice = "auto",
+    telemetry,
+    threadId,
+    resourceId,
+    memory,
+    runtimeContext,
+    ...rest
+  }) {
+    const model = this.#model;
+    this.logger.debug(`[LLM] - Generating a text object`, { runId });
+    const finalTools = convertedTools || this.convertTools({ tools, runId, threadId, resourceId, memory, runtimeContext });
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: async (props) => {
+        void onStepFinish?.(props);
+        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 chunkYTTBFAQJ_cjs.delay(10 * 1e3);
+        }
+      },
+      ...rest
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof zod.z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = ai.jsonSchema(structuredOutput);
+    }
+    return await ai.generateObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: {
+        ...this.experimental_telemetry,
+        ...telemetry
+      }
+    });
+  }
+  async __stream({
+    messages,
+    onStepFinish,
+    onFinish,
+    maxSteps = 5,
+    tools,
+    convertedTools,
+    runId,
+    temperature,
+    toolChoice = "auto",
+    experimental_output,
+    telemetry,
+    threadId,
+    resourceId,
+    memory,
+    runtimeContext,
+    ...rest
+  }) {
+    const model = this.#model;
+    this.logger.debug(`[LLM] - Streaming text`, {
+      runId,
+      threadId,
+      resourceId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools({ tools, runId, threadId, resourceId, memory, runtimeContext });
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: async (props) => {
+        void onStepFinish?.(props);
+        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 chunkYTTBFAQJ_cjs.delay(10 * 1e3);
+        }
+      },
+      onFinish: async (props) => {
+        void onFinish?.(props);
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId,
+          threadId,
+          resourceId
+        });
+      },
+      ...rest
+    };
+    let schema;
+    if (experimental_output) {
+      this.logger.debug("[LLM] - Using experimental output", {
+        runId
+      });
+      if (typeof experimental_output.parse === "function") {
+        schema = experimental_output;
+        if (schema instanceof zod.z.ZodArray) {
+          schema = schema._def.type;
+        }
+      } else {
+        schema = ai.jsonSchema(experimental_output);
+      }
+    }
+    return await ai.streamText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: {
+        ...this.experimental_telemetry,
+        ...telemetry
+      },
+      experimental_output: schema ? ai.Output.object({
+        schema
+      }) : void 0
+    });
+  }
+  async __streamObject({
+    messages,
+    runId,
+    tools,
+    convertedTools,
+    maxSteps = 5,
+    toolChoice = "auto",
+    runtimeContext,
+    threadId,
+    resourceId,
+    memory,
+    temperature,
+    onStepFinish,
+    onFinish,
+    structuredOutput,
+    telemetry,
+    ...rest
+  }) {
+    const model = this.#model;
+    this.logger.debug(`[LLM] - Streaming structured output`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools({ tools, runId, threadId, resourceId, memory, runtimeContext });
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: async (props) => {
+        void onStepFinish?.(props);
+        this.logger.debug("[LLM] - Stream Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId,
+          threadId,
+          resourceId
+        });
+        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 chunkYTTBFAQJ_cjs.delay(10 * 1e3);
+        }
+      },
+      onFinish: async (props) => {
+        void onFinish?.(props);
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId,
+          threadId,
+          resourceId
+        });
+      },
+      ...rest
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof zod.z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = ai.jsonSchema(structuredOutput);
+    }
+    return ai.streamObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: {
+        ...this.experimental_telemetry,
+        ...telemetry
+      }
+    });
+  }
+  async generate(messages, { maxSteps = 5, output, ...rest }) {
+    const msgs = this.convertToMessages(messages);
+    if (!output) {
+      return await this.__text({
+        messages: msgs,
+        maxSteps,
+        ...rest
+      });
+    }
+    return await this.__textObject({
+      messages: msgs,
+      structuredOutput: output,
+      maxSteps,
+      ...rest
+    });
+  }
+  async stream(messages, { maxSteps = 5, output, ...rest }) {
+    const msgs = this.convertToMessages(messages);
+    if (!output) {
+      return await this.__stream({
+        messages: msgs,
+        maxSteps,
+        ...rest
+      });
+    }
+    return await this.__streamObject({
+      messages: msgs,
+      structuredOutput: output,
+      maxSteps,
+      ...rest
+    });
+  }
+  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
+        });
+        return obj;
+      },
+      { chatMessages: [], toolResultContents: [] }
+    );
+    return chatMessages;
+  }
+};
+
+exports.MastraLLM = MastraLLM;

package/dist/{chunk-GEIPVIW4.js → chunk-BFF2O6RO.js}

@@ -1,4 +1,4 @@
-import { createTool } from './chunk-NTHHPNOW.js';
+import { createTool } from './chunk-34622N67.js';
 import { z } from 'zod';
 
 // src/integration/integration.ts

package/dist/{chunk-RASVJ3TR.js → chunk-BU45BMXY.js}

@@ -1,4 +1,4 @@
-import { DefaultProxyStorage, augmentWithInit } from './chunk-LANFNMEE.js';
+import { DefaultProxyStorage, augmentWithInit } from './chunk-SGTFVHOZ.js';
 import { InstrumentClass, Telemetry } from './chunk-HFOT2NFM.js';
 import { createLogger, LogLevel, noopLogger } from './chunk-2BVZNKLX.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
@@ -14,6 +14,7 @@ var Mastra = class {
   #agents;
   #logger;
   #workflows;
+  #vnext_workflows;
   #tts;
   #deployer;
   #serverMiddleware = [];
@@ -181,6 +182,22 @@ This is a warning for now, but will throw an error in the future
         }
       });
     }
+    this.#vnext_workflows = {};
+    if (config?.vnext_workflows) {
+      Object.entries(config.vnext_workflows).forEach(([key, workflow]) => {
+        workflow.__registerMastra(this);
+        workflow.__registerPrimitives({
+          logger: this.getLogger(),
+          telemetry: this.#telemetry,
+          storage: this.storage,
+          memory: this.memory,
+          agents,
+          tts: this.#tts,
+          vectors: this.#vectors
+        });
+        this.#vnext_workflows[key] = workflow;
+      });
+    }
     if (config?.server) {
       this.#server = config.server;
     }
@@ -225,6 +242,20 @@ This is a warning for now, but will throw an error in the future
     }
     return workflow;
   }
+  vnext_getWorkflow(id, {
+    serialized
+  } = {}) {
+    const workflow = this.#vnext_workflows?.[id];
+    if (!workflow) {
+      throw new Error(`Workflow with ID ${String(id)} not found`);
+    }
+    if (serialized) {
+      return {
+        name: workflow.name
+      };
+    }
+    return workflow;
+  }
   getWorkflows(props = {}) {
     if (props.serialized) {
       return Object.entries(this.#workflows).reduce((acc, [k, v]) => {
@@ -238,7 +269,30 @@ This is a warning for now, but will throw an error in the future
     }
     return this.#workflows;
   }
+  vnext_getWorkflows(props = {}) {
+    if (props.serialized) {
+      return Object.entries(this.#vnext_workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.#vnext_workflows;
+  }
   setStorage(storage) {
+    if (storage instanceof DefaultProxyStorage) {
+      this.#logger.warn(`Importing "DefaultStorage" from '@mastra/core/storage/libsql' is deprecated.
+
+Instead of:
+  import { DefaultStorage } from '@mastra/core/storage/libsql';
+
+Do:
+  import { LibSQLStore } from '@mastra/libsql';
+`);
+    }
     this.#storage = augmentWithInit(storage);
   }
   setLogger({

package/dist/{chunk-DIZZQ3E5.cjs → chunk-CEXM6WP5.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkATXF6TIO_cjs = require('./chunk-ATXF6TIO.cjs');
+var chunk422BXQRT_cjs = require('./chunk-422BXQRT.cjs');
 var cohereAi = require('cohere-ai');
 
 var CohereRelevanceScorer = class {
@@ -38,7 +38,7 @@ Relevance score (0-1):`;
 var MastraAgentRelevanceScorer = class {
   agent;
   constructor(name, model) {
-    this.agent = new chunkATXF6TIO_cjs.Agent({
+    this.agent = new chunk422BXQRT_cjs.Agent({
       name: `Relevance Scorer ${name}`,
       instructions: `You are a specialized agent for evaluating the relevance of text to queries.
 Your task is to rate how well a text passage answers a given query.