@mastra/core 0.2.0-alpha.93 → 0.2.0-alpha.95

package/dist/chunk-RI3ECMVF.js

@@ -1,636 +0,0 @@
-import { InstrumentClass } from './chunk-6ZVFVYLE.js';
-import { delay } from './chunk-KNPBNSJ7.js';
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { RegisteredLogger, LogLevel } from './chunk-ICMEXHKD.js';
-import { __name, __privateAdd, __privateSet, __privateGet } from './chunk-AJJZUHB4.js';
-import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
-import { createAnthropic } from '@ai-sdk/anthropic';
-import { createAzure } from '@ai-sdk/azure';
-import { createCohere } from '@ai-sdk/cohere';
-import { createGoogleGenerativeAI } from '@ai-sdk/google';
-import { createMistral } from '@ai-sdk/mistral';
-import { createOpenAI } from '@ai-sdk/openai';
-import { createXai } from '@ai-sdk/xai';
-import { tool, generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
-import { createAnthropicVertex } from 'anthropic-vertex-ai';
-import { z } from 'zod';
-
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var _model, _mastra;
-var _LLM = class _LLM extends MastraBase {
-  constructor({ model }) {
-    super({
-      component: RegisteredLogger.LLM
-    });
-    __privateAdd(this, _model);
-    __privateAdd(this, _mastra);
-    __privateSet(this, _model, model);
-    __privateSet(this, _mastra, {});
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    __privateSet(this, _mastra, p);
-  }
-  getModelType() {
-    const model = __privateGet(this, _model);
-    if (!("provider" in model)) {
-      throw new Error("Model provider is required");
-    }
-    const providerToType = {
-      OPEN_AI: "openai",
-      ANTHROPIC: "anthropic",
-      GROQ: "groq",
-      PERPLEXITY: "perplexity",
-      FIREWORKS: "fireworks",
-      TOGETHER_AI: "togetherai",
-      LM_STUDIO: "lmstuido",
-      BASETEN: "baseten",
-      GOOGLE: "google",
-      MISTRAL: "mistral",
-      X_GROK: "grok",
-      COHERE: "cohere",
-      AZURE: "azure",
-      AMAZON: "amazon",
-      ANTHROPIC_VERTEX: "anthropic-vertex",
-      DEEPSEEK: "deepseek"
-    };
-    const type = providerToType[model.provider] ?? model.provider;
-    this.logger.debug(`[LLM] - Model resolved to provider ${model.provider}`, {
-      sdk_type: type,
-      provider: model.provider
-    });
-    return type;
-  }
-  createOpenAICompatibleModel({ baseURL, apiKey, defaultModelName, modelName, fetch }) {
-    this.log(LogLevel.DEBUG, `Creating OpenAI compatible model with baseURL: ${baseURL}`);
-    const client = createOpenAI({
-      baseURL,
-      apiKey,
-      fetch
-    });
-    return client(modelName || defaultModelName);
-  }
-  createModelDef({ model }) {
-    let modelDef;
-    if (model.type === "openai") {
-      this.logger.debug(`[LLM] - Initializing OpenAI model ${model.name || "gpt-4o-2024-08-06"}`);
-      const openai = createOpenAI({
-        apiKey: model?.apiKey || process.env.OPENAI_API_KEY
-      });
-      modelDef = openai(model.name || "gpt-4o-2024-08-06", {
-        structuredOutputs: true
-      });
-    } else if (model.type === "anthropic") {
-      this.log(LogLevel.DEBUG, `Initializing Anthropic model ${model.name || "claude-3-5-sonnet-20240620"}`);
-      const anthropic = createAnthropic({
-        apiKey: model?.apiKey || process.env.ANTHROPIC_API_KEY
-      });
-      modelDef = anthropic(model.name || "claude-3-5-sonnet-20240620");
-    } else if (model.type === "google") {
-      this.log(LogLevel.DEBUG, `Initializing Google model ${model.name || "gemini-1.5-pro-latest"}`);
-      const google = createGoogleGenerativeAI({
-        baseURL: "https://generativelanguage.googleapis.com/v1beta",
-        apiKey: model?.apiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY || ""
-      });
-      modelDef = google(model.name || "gemini-1.5-pro-latest");
-    } else if (model.type === "groq") {
-      this.log(LogLevel.DEBUG, `Initializing Groq model ${model.name || "llama-3.2-90b-text-preview"}`);
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://api.groq.com/openai/v1",
-        apiKey: model?.apiKey || process.env.GROQ_API_KEY || "",
-        defaultModelName: "llama-3.2-90b-text-preview",
-        modelName: model.name
-      });
-    } else if (model.type === "perplexity") {
-      this.log(LogLevel.DEBUG, `Initializing Perplexity model ${model.name || "llama-3.1-sonar-large-128k-chat"}`);
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://api.perplexity.ai/",
-        apiKey: model?.apiKey || process.env.PERPLEXITY_API_KEY || "",
-        defaultModelName: "llama-3.1-sonar-large-128k-chat",
-        modelName: model.name
-      });
-    } else if (model.type === "fireworks") {
-      this.log(LogLevel.DEBUG, `Initializing Fireworks model ${model.name || "llama-v3p1-70b-instruct"}`);
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://api.fireworks.ai/inference/v1",
-        apiKey: model?.apiKey || process.env.FIREWORKS_API_KEY || "",
-        defaultModelName: "llama-v3p1-70b-instruct",
-        modelName: model.name
-      });
-    } else if (model.type === "togetherai") {
-      this.log(LogLevel.DEBUG, `Initializing TogetherAI model ${model.name || "google/gemma-2-9b-it"}`);
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://api.together.xyz/v1/",
-        apiKey: model?.apiKey || process.env.TOGETHER_AI_API_KEY || "",
-        defaultModelName: "google/gemma-2-9b-it",
-        modelName: model.name
-      });
-    } else if (model.type === "lmstudio") {
-      this.log(LogLevel.DEBUG, `Initializing LMStudio model ${model.name || "llama-3.2-1b"}`);
-      if (!model?.baseURL) {
-        const error = `LMStudio model requires a baseURL`;
-        this.logger.error(error);
-        throw new Error(error);
-      }
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: model.baseURL,
-        apiKey: "not-needed",
-        defaultModelName: "llama-3.2-1b",
-        modelName: model.name
-      });
-    } else if (model.type === "baseten") {
-      this.log(LogLevel.DEBUG, `Initializing BaseTen model ${model.name || "llama-3.1-70b-instruct"}`);
-      if (model?.fetch) {
-        const error = `Custom fetch is required to use ${model.type}. see https://docs.baseten.co/api-reference/openai for more information`;
-        this.logger.error(error);
-        throw new Error(error);
-      }
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://bridge.baseten.co/v1/direct",
-        apiKey: model?.apiKey || process.env.BASETEN_API_KEY || "",
-        defaultModelName: "llama-3.1-70b-instruct",
-        modelName: model.name
-      });
-    } else if (model.type === "mistral") {
-      this.log(LogLevel.DEBUG, `Initializing Mistral model ${model.name || "pixtral-large-latest"}`);
-      const mistral = createMistral({
-        baseURL: "https://api.mistral.ai/v1",
-        apiKey: model?.apiKey || process.env.MISTRAL_API_KEY || ""
-      });
-      modelDef = mistral(model.name || "pixtral-large-latest");
-    } else if (model.type === "grok") {
-      this.log(LogLevel.DEBUG, `Initializing X Grok model ${model.name || "grok-beta"}`);
-      const xAi = createXai({
-        baseURL: "https://api.x.ai/v1",
-        apiKey: process.env.XAI_API_KEY ?? ""
-      });
-      modelDef = xAi(model.name || "grok-beta");
-    } else if (model.type === "cohere") {
-      this.log(LogLevel.DEBUG, `Initializing Cohere model ${model.name || "command-r-plus"}`);
-      const cohere = createCohere({
-        baseURL: "https://api.cohere.com/v2",
-        apiKey: model?.apiKey || process.env.COHERE_API_KEY || ""
-      });
-      modelDef = cohere(model.name || "command-r-plus");
-    } else if (model.type === "azure") {
-      this.log(LogLevel.DEBUG, `Initializing Azure model ${model.name || "gpt-35-turbo-instruct"}`);
-      const azure = createAzure({
-        resourceName: process.env.AZURE_RESOURCE_NAME || "",
-        apiKey: model?.apiKey || process.env.AZURE_API_KEY || "",
-        apiVersion: model?.apiVersion,
-        baseURL: model?.baseURL,
-        headers: model?.headers,
-        fetch: model?.fetch
-      });
-      modelDef = azure(model.name || "gpt-35-turbo-instruct");
-    } else if (model.type === "amazon") {
-      this.log(LogLevel.DEBUG, `Initializing Amazon model ${model.name || "amazon-titan-tg1-large"}`);
-      const amazon = createAmazonBedrock({
-        region: process.env.AWS_REGION || "",
-        accessKeyId: process.env.AWS_ACCESS_KEY_ID || "",
-        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || "",
-        sessionToken: process.env.AWS_SESSION_TOKEN || ""
-      });
-      modelDef = amazon(model.name || "amazon-titan-tg1-large");
-    } else if (model.type === "anthropic-vertex") {
-      this.log(LogLevel.DEBUG, `Initializing Anthropic Vertex model ${model.name || "claude-3-5-sonnet@20240620"}`);
-      const anthropicVertex = createAnthropicVertex({
-        region: process.env.GOOGLE_VERTEX_REGION,
-        projectId: process.env.GOOGLE_VERTEX_PROJECT_ID,
-        apiKey: process.env.ANTHROPIC_API_KEY ?? ""
-      });
-      modelDef = anthropicVertex(model.name || "claude-3-5-sonnet@20240620");
-    } else if (model.type === "deepseek") {
-      this.log(LogLevel.DEBUG, `Initializing Deepseek model ${model.name || "deepseek-chat"}`);
-      modelDef = this.createOpenAICompatibleModel({
-        baseURL: "https://api.deepseek.com/v1/",
-        apiKey: model?.apiKey || process.env.DEEPSEEK_API_KEY || "",
-        defaultModelName: "deepseek-chat",
-        modelName: model.name
-      });
-    } else {
-      const error = `Invalid model type: ${model.type}`;
-      this.logger.error(error);
-      throw new Error(error);
-    }
-    return modelDef;
-  }
-  async getParams({ tools, resultTool, model }) {
-    const toolsConverted = Object.entries(tools).reduce((memo, [key, val]) => {
-      memo[key] = tool(val);
-      return memo;
-    }, {});
-    let answerTool = {};
-    if (resultTool) {
-      answerTool = {
-        answer: tool(resultTool)
-      };
-    }
-    let modelDef;
-    if ("type" in model) {
-      modelDef = this.createModelDef({
-        model
-      });
-    } else {
-      if (model.model instanceof Function) {
-        modelDef = await model.model();
-      } else {
-        modelDef = model.model;
-      }
-    }
-    return {
-      toolsConverted,
-      modelDef,
-      answerTool,
-      toolChoice: model.toolChoice || "auto"
-    };
-  }
-  convertTools(tools) {
-    const converted = Object.entries(tools || {}).reduce((memo, value) => {
-      const k = value[0];
-      const tool2 = value[1];
-      if (tool2) {
-        memo[k] = {
-          description: tool2.description,
-          parameters: tool2.inputSchema,
-          execute: /* @__PURE__ */ __name(async (props) => {
-            try {
-              this.logger.debug(`Executing tool ${k}`, {
-                tool: k,
-                props
-              });
-              return tool2.execute({
-                context: props,
-                mastra: __privateGet(this, _mastra)
-              });
-            } catch (error) {
-              this.logger.error(`Error executing tool ${k}`, {
-                tool: k,
-                props,
-                error
-              });
-              throw error;
-            }
-          }, "execute")
-        };
-      }
-      return memo;
-    }, {});
-    return converted;
-  }
-  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
-      }
-    ];
-  }
-  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
-    });
-  }
-  async __text({ messages, onStepFinish, maxSteps = 5, tools, runId, convertedTools, temperature }) {
-    const model = __privateGet(this, _model);
-    this.logger.debug(`[LLM] - Generating text`, {
-      runId,
-      messages,
-      maxSteps,
-      tools: Object.keys(tools || convertedTools || {})
-    });
-    let modelToPass;
-    if ("name" in model) {
-      modelToPass = this.__getNamedModel();
-    } else {
-      modelToPass = model;
-    }
-    const params = await this.getParams({
-      tools: convertedTools || this.convertTools(tools),
-      model: modelToPass
-    });
-    const argsForExecute = {
-      model: params.modelDef,
-      temperature,
-      tools: {
-        ...params.toolsConverted,
-        ...params.answerTool
-      },
-      toolChoice: params.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
-    });
-  }
-  __getNamedModel() {
-    const model = __privateGet(this, _model);
-    if (!("name" in model)) {
-      throw new Error("Model name is required");
-    }
-    return {
-      type: this.getModelType(),
-      name: model.name,
-      toolChoice: model.toolChoice,
-      apiKey: model?.apiKey,
-      baseURL: model?.baseURL,
-      headers: model?.headers,
-      fetch: model?.fetch
-    };
-  }
-  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
-    });
-    let modelToPass;
-    if ("name" in model) {
-      modelToPass = this.__getNamedModel();
-    } else {
-      modelToPass = model;
-    }
-    const params = await this.getParams({
-      tools: convertedTools || this.convertTools(tools),
-      model: modelToPass
-    });
-    const argsForExecute = {
-      model: params.modelDef,
-      temperature,
-      tools: {
-        ...params.toolsConverted,
-        ...params.answerTool
-      },
-      toolChoice: params.toolChoice,
-      maxSteps,
-      onStepFinish: /* @__PURE__ */ __name(async (props) => {
-        this.logger.debug("[LLM] - Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage
-        });
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        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, runId, convertedTools, temperature }) {
-    const model = __privateGet(this, _model);
-    this.log(LogLevel.DEBUG, `Streaming text with ${messages.length} messages`, {
-      runId
-    });
-    let modelToPass;
-    if ("name" in model) {
-      modelToPass = this.__getNamedModel();
-    } else {
-      modelToPass = model;
-    }
-    const params = await this.getParams({
-      tools: convertedTools || this.convertTools(tools),
-      model: modelToPass
-    });
-    const argsForExecute = {
-      temperature,
-      model: params.modelDef,
-      tools: {
-        ...params.toolsConverted,
-        ...params.answerTool
-      },
-      toolChoice: params.toolChoice,
-      maxSteps,
-      onStepFinish: /* @__PURE__ */ __name(async (props) => {
-        this.logger.debug("[LLM] - Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage
-        });
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        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) => {
-        this.logger.debug("[LLM] - On Finish:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage
-        });
-        onFinish?.(JSON.stringify(props, null, 2));
-      }, "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.log(LogLevel.DEBUG, `Streaming text with ${messages.length} messages`, {
-      runId
-    });
-    let modelToPass;
-    if ("name" in model) {
-      modelToPass = this.__getNamedModel();
-    } else {
-      modelToPass = model;
-    }
-    const params = await this.getParams({
-      tools: convertedTools || this.convertTools(tools),
-      model: modelToPass
-    });
-    const argsForExecute = {
-      temperature,
-      model: params.modelDef,
-      tools: {
-        ...params.toolsConverted,
-        ...params.answerTool
-      },
-      toolChoice: params.toolChoice,
-      maxSteps,
-      onStepFinish: /* @__PURE__ */ __name(async (props) => {
-        this.logger.debug("[LLM] - Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage
-        });
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        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) => {
-        this.logger.debug("[LLM] - On Finish:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage
-        });
-        onFinish?.(JSON.stringify(props, null, 2));
-      }, "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 await streamObject({
-      messages,
-      ...argsForExecute,
-      output,
-      schema,
-      experimental_telemetry: this.experimental_telemetry
-    });
-  }
-};
-_model = new WeakMap();
-_mastra = new WeakMap();
-__name(_LLM, "LLM");
-var LLM = _LLM;
-LLM = _ts_decorate([
-  InstrumentClass({
-    prefix: "llm",
-    excludeMethods: [
-      "__setTools",
-      "__setLogger",
-      "__setTelemetry",
-      "#log"
-    ]
-  }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    Object
-  ])
-], LLM);
-
-export { LLM };

package/dist/chunk-VPSYTVWP.js

@@ -1,66 +0,0 @@
-import { MastraEmbedder } from './chunk-AD6IIOCI.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-import { createCohere } from '@ai-sdk/cohere';
-import { embed as embed$1, embedMany as embedMany$1 } from 'ai';
-
-async function embed(value, { apiKey = process.env.COHERE_API_KEY || "", model = "embed-english-v3.0", baseURL, maxRetries = 3 }) {
-  const cohere = createCohere({
-    baseURL,
-    apiKey
-  });
-  const eModel = cohere.textEmbeddingModel(model);
-  return await embed$1({
-    model: eModel,
-    value,
-    maxRetries
-  });
-}
-__name(embed, "embed");
-async function embedMany(values, { apiKey = process.env.COHERE_API_KEY || "", model = "embed-english-v3.0", baseURL, maxRetries = 3 }) {
-  const cohere = createCohere({
-    baseURL,
-    apiKey
-  });
-  const eModel = cohere.textEmbeddingModel(model);
-  return await embedMany$1({
-    model: eModel,
-    values,
-    maxRetries
-  });
-}
-__name(embedMany, "embedMany");
-var _CohereEmbedder = class _CohereEmbedder extends MastraEmbedder {
-  constructor({ apiKey = process.env.COHERE_API_KEY || "", model = "embed-english-v3.0", baseURL }) {
-    super();
-    __publicField(this, "apiKey");
-    __publicField(this, "model");
-    __publicField(this, "baseURL");
-    this.apiKey = apiKey;
-    this.model = model;
-    this.baseURL = baseURL;
-  }
-  async embed(value, { maxRetries } = {
-    maxRetries: 3
-  }) {
-    return embed(value, {
-      apiKey: this.apiKey,
-      model: this.model,
-      baseURL: this.baseURL,
-      maxRetries
-    });
-  }
-  async embedMany(values, { maxRetries } = {
-    maxRetries: 3
-  }) {
-    return embedMany(values, {
-      apiKey: this.apiKey,
-      model: this.model,
-      baseURL: this.baseURL,
-      maxRetries
-    });
-  }
-};
-__name(_CohereEmbedder, "CohereEmbedder");
-var CohereEmbedder = _CohereEmbedder;
-
-export { CohereEmbedder, embed, embedMany };