@mastra/core 0.9.0 → 0.9.1-alpha.1

package/dist/{chunk-HARYMLZH.js → chunk-4K4DHXRF.js}

@@ -1,16 +1,16 @@
 import { DefaultVoice } from './chunk-MWLZJBPF.js';
+import { MastraLLM } from './chunk-VMVXIPGW.js';
 import { InstrumentClass } from './chunk-HFOT2NFM.js';
-import { ensureToolProperties, ensureAllMessagesAreCoreMessages, createMastraProxy, makeCoreTool, delay } from './chunk-NTHHPNOW.js';
+import { ensureToolProperties, ensureAllMessagesAreCoreMessages, createMastraProxy, makeCoreTool } from './chunk-34622N67.js';
 import { MastraBase } from './chunk-CLJQYXNM.js';
 import { RegisteredLogger } from './chunk-2BVZNKLX.js';
-import { RuntimeContext } from './chunk-M472GIT6.js';
+import { RuntimeContext } from './chunk-SGGPJWRQ.js';
 import { executeHook } from './chunk-BB4KXGBU.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 import { context, trace } from '@opentelemetry/api';
 import { z } from 'zod';
 import { get } from 'radash';
 import { randomUUID } from 'crypto';
-import { jsonSchema, generateText, Output, generateObject, streamText, streamObject } from 'ai';
 import EventEmitter from 'node:events';
 import sift from 'sift';
 import { createActor, assign, fromPromise, setup } from 'xstate';
@@ -43,9 +43,6 @@ var Step = class {
     this.retryConfig = retryConfig;
   }
 };
-function createStep(opts) {
-  return new Step(opts);
-}
 
 // src/workflows/types.ts
 var WhenConditionReturnValue = /* @__PURE__ */(WhenConditionReturnValue2 => {
@@ -55,663 +52,13 @@ var WhenConditionReturnValue = /* @__PURE__ */(WhenConditionReturnValue2 => {
   WhenConditionReturnValue2["LIMBO"] = "limbo";
   return WhenConditionReturnValue2;
 })(WhenConditionReturnValue || {});
-
-// src/llm/model/base.ts
-var MastraLLMBase = class extends MastraBase {
-  // @ts-ignore
-  #mastra;
-  #model;
-  constructor({
-    name,
-    model
-  }) {
-    super({
-      component: 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.");
-  }
-};
-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 = 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] = 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 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 z.ZodArray) {
-          schema = schema._def.type;
-        }
-      } else {
-        schema = jsonSchema(experimental_output);
-      }
-    }
-    return await generateText({
-      messages,
-      ...argsForExecute,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      },
-      experimental_output: schema ? 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 delay(10 * 1e3);
-        }
-      },
-      ...rest
-    };
-    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,
-        ...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 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 z.ZodArray) {
-          schema = schema._def.type;
-        }
-      } else {
-        schema = jsonSchema(experimental_output);
-      }
-    }
-    return await streamText({
-      messages,
-      ...argsForExecute,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      },
-      experimental_output: schema ? 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 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 z.ZodArray) {
-        output = "array";
-        schema = schema._def.type;
-      }
-    } else {
-      schema = jsonSchema(structuredOutput);
-    }
-    return 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;
-  }
-};
-
-// src/agent/index.ts
 var _Agent_decorators, _init, _a;
 _Agent_decorators = [InstrumentClass({
   prefix: "agent",
   excludeMethods: ["hasOwnMemory", "getMemory", "__primitive", "__setTools", "__setLogger", "__setTelemetry", "log"]
 })];
 var Agent = class extends (_a = MastraBase) {
+  id;
   name;
   llm;
   instructions;
@@ -730,6 +77,7 @@ var Agent = class extends (_a = MastraBase) {
       component: RegisteredLogger.AGENT
     });
     this.name = config.name;
+    this.id = config.name;
     this.instructions = config.instructions;
     if (!config.model) {
       throw new Error(`LanguageModel is required to create an Agent. Please provide the 'model'.`);
@@ -4727,4 +4075,4 @@ var Workflow = class extends MastraBase {
   }
 };
 
-export { Agent, Step, WhenConditionReturnValue, Workflow, agentToStep, createStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };
+export { Agent, Step, WhenConditionReturnValue, Workflow, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };