@mastra/core 0.2.0-alpha.83 → 0.2.0-alpha.86

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,8 +1,8 @@
 import 'zod';
-export { I as IAction, aR as IExecutionContext, d as MastraPrimitives } from '../index-CA9EWqaj.js';
+export { I as IAction, aT as IExecutionContext, d as MastraPrimitives } from '../index-Duqv1Yom.js';
 import '../engine-EwEG-4Iv.js';
-import '../index-B9i6dmc0.js';
-import '../telemetry/index.js';
+import '../index-B0-NXUYv.js';
+import '../telemetry-oCUM52DG.js';
 import '../tts/index.js';
 import '../vector/index.js';
 import 'ai';

package/dist/agent/index.d.ts

@@ -1,18 +1,18 @@
 import 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent } from '../index-CA9EWqaj.js';
+export { A as Agent } from '../index-Duqv1Yom.js';
 import '../base.js';
 import '../metric-D2V4CR8D.js';
-import '../telemetry/index.js';
-import '@opentelemetry/api';
-import '@opentelemetry/sdk-node';
-import '@opentelemetry/sdk-trace-base';
-import '../index-B9i6dmc0.js';
+import '../telemetry-oCUM52DG.js';
+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,9 +1,9 @@
-export { Agent } from '../chunk-RPBNMIV7.js';
-import '../chunk-OZZS5Y3C.js';
-import '../chunk-K7KUCZT2.js';
+export { Agent } from '../chunk-73XDWPXJ.js';
+import '../chunk-HBTQNIAX.js';
+import '../chunk-SDKEPBBH.js';
+import '../chunk-6WJREZ5F.js';
 import '../chunk-6ZVFVYLE.js';
 import '../chunk-LUULSM4U.js';
-import '../chunk-27EL4TRB.js';
-import '../chunk-NLQVQJOD.js';
-import '../chunk-HBTQNIAX.js';
+import '../chunk-JCRGAEY6.js';
+import '../chunk-TJK6TGSR.js';
 import '../chunk-AJJZUHB4.js';

package/dist/base.d.ts

@@ -1,6 +1,6 @@
 import * as _opentelemetry_api from '@opentelemetry/api';
-import { R as RegisteredLogger, L as Logger, a as LogLevel } from './index-B9i6dmc0.js';
-import { Telemetry } from './telemetry/index.js';
+import { R as RegisteredLogger, L as Logger, a as LogLevel } from './index-B0-NXUYv.js';
+import { T as Telemetry } from './telemetry-oCUM52DG.js';
 import 'pino';
 import 'stream';
 import '@opentelemetry/sdk-node';
@@ -8,7 +8,7 @@ import '@opentelemetry/sdk-trace-base';
 
 declare class MastraBase {
     component: RegisteredLogger;
-    logger: Logger;
+    protected logger: Logger;
     name?: string;
     telemetry?: Telemetry;
     constructor({ component, name }: {

package/dist/base.js

@@ -1,3 +1,3 @@
-export { MastraBase } from './chunk-27EL4TRB.js';
-import './chunk-NLQVQJOD.js';
+export { MastraBase } from './chunk-JCRGAEY6.js';
+import './chunk-TJK6TGSR.js';
 import './chunk-AJJZUHB4.js';

package/dist/bundler/index.d.ts

@@ -0,0 +1,21 @@
+import { MastraBase } from '../base.js';
+import '@opentelemetry/api';
+import '../index-B0-NXUYv.js';
+import 'pino';
+import 'stream';
+import '../telemetry-oCUM52DG.js';
+import '@opentelemetry/sdk-node';
+import '@opentelemetry/sdk-trace-base';
+
+declare abstract class MastraBundler extends MastraBase {
+    constructor({ name, component }: {
+        name: string;
+        component?: 'BUNDLER' | 'DEPLOYER';
+    });
+    loadEnvVars(): Promise<Map<string, string>>;
+    abstract prepare(outputDirectory: string): Promise<void>;
+    abstract getEnvFiles(): Promise<string[]>;
+    abstract bundle(mastraDir: string, outputDirectory: string): Promise<void>;
+}
+
+export { MastraBundler };

package/dist/bundler/index.js

@@ -0,0 +1,4 @@
+export { MastraBundler } from '../chunk-CQYUMNLZ.js';
+import '../chunk-JCRGAEY6.js';
+import '../chunk-TJK6TGSR.js';
+import '../chunk-AJJZUHB4.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-K7KUCZT2.js → chunk-6WJREZ5F.js}

@@ -1,7 +1,7 @@
 import { InstrumentClass } from './chunk-6ZVFVYLE.js';
 import { delay } from './chunk-LUULSM4U.js';
-import { MastraBase } from './chunk-27EL4TRB.js';
-import { RegisteredLogger, LogLevel } from './chunk-NLQVQJOD.js';
+import { MastraBase } from './chunk-JCRGAEY6.js';
+import { RegisteredLogger, LogLevel } from './chunk-TJK6TGSR.js';
 import { __name, __privateAdd, __privateSet, __privateGet } from './chunk-AJJZUHB4.js';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';