@mastra/core 0.10.13 → 0.10.14

package/dist/chunk-AKYTYALY.js

@@ -0,0 +1,70 @@
+import { executeHook } from './chunk-BB4KXGBU.js';
+import { MastraError } from './chunk-6UNGH46J.js';
+
+// src/eval/metric.ts
+var Metric = class {
+};
+
+// src/eval/evaluation.ts
+async function evaluate({
+  agentName,
+  input,
+  metric,
+  output,
+  runId,
+  globalRunId,
+  testInfo,
+  instructions
+}) {
+  const runIdToUse = runId || crypto.randomUUID();
+  let metricResult;
+  let metricName = metric.constructor.name;
+  try {
+    metricResult = await metric.measure(input.toString(), output);
+  } catch (e) {
+    throw new MastraError(
+      {
+        id: "EVAL_METRIC_MEASURE_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  const traceObject = {
+    input: input.toString(),
+    output,
+    result: metricResult,
+    agentName,
+    metricName,
+    instructions,
+    globalRunId,
+    runId: runIdToUse,
+    testInfo
+  };
+  try {
+    executeHook("onEvaluation" /* ON_EVALUATION */, traceObject);
+  } catch (e) {
+    throw new MastraError(
+      {
+        id: "EVAL_HOOK_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  return { ...metricResult, output };
+}
+
+export { Metric, evaluate };

package/dist/chunk-ATXBSEFT.js

@@ -0,0 +1,22 @@
+import { MastraBase } from './chunk-5IEKR756.js';
+import { readFile } from 'fs/promises';
+import { parse } from 'dotenv';
+
+var MastraBundler = class extends MastraBase {
+  constructor({ name, component = "BUNDLER" }) {
+    super({ component, name });
+  }
+  async loadEnvVars() {
+    const envVars = /* @__PURE__ */ new Map();
+    for (const file of await this.getEnvFiles()) {
+      const content = await readFile(file, "utf-8");
+      const config = parse(content);
+      Object.entries(config).forEach(([key, value]) => {
+        envVars.set(key, value);
+      });
+    }
+    return envVars;
+  }
+};
+
+export { MastraBundler };

package/dist/chunk-B6TOBUS6.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+// src/error/index.ts
+var ErrorDomain = /* @__PURE__ */ ((ErrorDomain2) => {
+  ErrorDomain2["TOOL"] = "TOOL";
+  ErrorDomain2["AGENT"] = "AGENT";
+  ErrorDomain2["MCP"] = "MCP";
+  ErrorDomain2["AGENT_NETWORK"] = "AGENT_NETWORK";
+  ErrorDomain2["MASTRA_SERVER"] = "MASTRA_SERVER";
+  ErrorDomain2["MASTRA_TELEMETRY"] = "MASTRA_TELEMETRY";
+  ErrorDomain2["MASTRA_WORKFLOW"] = "MASTRA_WORKFLOW";
+  ErrorDomain2["MASTRA_VOICE"] = "MASTRA_VOICE";
+  ErrorDomain2["MASTRA_VECTOR"] = "MASTRA_VECTOR";
+  ErrorDomain2["LLM"] = "LLM";
+  ErrorDomain2["EVAL"] = "EVAL";
+  ErrorDomain2["A2A"] = "A2A";
+  ErrorDomain2["MASTRA_INSTANCE"] = "MASTRA_INSTANCE";
+  ErrorDomain2["MASTRA"] = "MASTRA";
+  ErrorDomain2["DEPLOYER"] = "DEPLOYER";
+  ErrorDomain2["STORAGE"] = "STORAGE";
+  return ErrorDomain2;
+})(ErrorDomain || {});
+var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
+  ErrorCategory2["UNKNOWN"] = "UNKNOWN";
+  ErrorCategory2["USER"] = "USER";
+  ErrorCategory2["SYSTEM"] = "SYSTEM";
+  ErrorCategory2["THIRD_PARTY"] = "THIRD_PARTY";
+  return ErrorCategory2;
+})(ErrorCategory || {});
+var MastraBaseError = class extends Error {
+  id;
+  domain;
+  category;
+  details = {};
+  message;
+  constructor(errorDefinition, originalError) {
+    let error;
+    if (originalError instanceof Error) {
+      error = originalError;
+    } else if (originalError) {
+      error = new Error(String(originalError));
+    }
+    const message = errorDefinition.text ?? error?.message ?? "Unknown error";
+    super(message, { cause: error });
+    this.id = errorDefinition.id;
+    this.domain = errorDefinition.domain;
+    this.category = errorDefinition.category;
+    this.details = errorDefinition.details ?? {};
+    this.message = message;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Returns a structured representation of the error, useful for logging or API responses.
+   */
+  toJSONDetails() {
+    return {
+      message: this.message,
+      domain: this.domain,
+      category: this.category,
+      details: this.details
+    };
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      details: this.toJSONDetails(),
+      code: this.id
+    };
+  }
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+};
+var MastraError = class extends MastraBaseError {
+};
+
+exports.ErrorCategory = ErrorCategory;
+exports.ErrorDomain = ErrorDomain;
+exports.MastraBaseError = MastraBaseError;
+exports.MastraError = MastraError;

package/dist/chunk-B7SQOKEC.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var chunk4Z3OU5RY_cjs = require('./chunk-4Z3OU5RY.cjs');
+var zod = require('zod');
+
+// src/integration/integration.ts
+var Integration = class {
+  name = "Integration";
+  workflows;
+  constructor() {
+    this.workflows = {};
+  }
+  /**
+   * Workflows
+   */
+  registerWorkflow(name, fn) {
+    if (this.workflows[name]) {
+      throw new Error(`Sync function "${name}" already registered`);
+    }
+    this.workflows[name] = fn;
+  }
+  getWorkflows({ serialized }) {
+    if (serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  /**
+   * TOOLS
+   */
+  getStaticTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getApiClient() {
+    throw new Error("Method not implemented");
+  }
+};
+var OpenAPIToolset = class {
+  authType = "API_KEY";
+  constructor() {
+  }
+  get toolSchemas() {
+    return {};
+  }
+  get toolDocumentations() {
+    return {};
+  }
+  get baseClient() {
+    return {};
+  }
+  async getApiClient() {
+    throw new Error("API not implemented");
+  }
+  _generateIntegrationTools() {
+    const { client: _client, ...clientMethods } = this.baseClient;
+    const schemas = this.toolSchemas;
+    const documentations = this.toolDocumentations;
+    const tools = Object.keys(clientMethods).reduce((acc, key) => {
+      const comment = documentations[key]?.comment;
+      const fallbackComment = `Execute ${key}`;
+      const tool = chunk4Z3OU5RY_cjs.createTool({
+        id: key,
+        inputSchema: schemas[key] || zod.z.object({}),
+        description: comment || fallbackComment,
+        // documentation: doc || fallbackComment,
+        execute: async ({ context }) => {
+          const client = await this.getApiClient();
+          const value = client[key];
+          return value({
+            ...context
+          });
+        }
+      });
+      return { ...acc, [key]: tool };
+    }, {});
+    return tools;
+  }
+};
+
+exports.Integration = Integration;
+exports.OpenAPIToolset = OpenAPIToolset;

package/dist/chunk-BB4KXGBU.js

@@ -0,0 +1,83 @@
+// src/hooks/mitt.ts
+function mitt(all) {
+  all = all || /* @__PURE__ */ new Map();
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @memberOf mitt
+     */
+    on(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all.set(type, [handler]);
+      }
+    },
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     * @memberOf mitt
+     */
+    off(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all.set(type, []);
+        }
+      }
+    },
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf mitt
+     */
+    emit(type, evt) {
+      let handlers = all.get(type);
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(evt);
+        });
+      }
+      handlers = all.get("*");
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(type, evt);
+        });
+      }
+    }
+  };
+}
+
+// src/hooks/index.ts
+var AvailableHooks = /* @__PURE__ */ ((AvailableHooks2) => {
+  AvailableHooks2["ON_EVALUATION"] = "onEvaluation";
+  AvailableHooks2["ON_GENERATION"] = "onGeneration";
+  return AvailableHooks2;
+})(AvailableHooks || {});
+var hooks = mitt();
+function registerHook(hook, action) {
+  hooks.on(hook, action);
+}
+function executeHook(hook, data) {
+  setImmediate(() => {
+    hooks.emit(hook, data);
+  });
+}
+
+export { AvailableHooks, executeHook, registerHook };

package/dist/chunk-BB6DPGIV.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+// src/workflows/constants.ts
+var EMITTER_SYMBOL = Symbol("emitter");
+
+exports.EMITTER_SYMBOL = EMITTER_SYMBOL;

package/dist/chunk-C4LMN2IR.js

@@ -0,0 +1,27 @@
+// src/tools/tool.ts
+var Tool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  mastra;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+    this.mastra = opts.mastra;
+  }
+};
+function createTool(opts) {
+  return new Tool(opts);
+}
+
+// src/tools/toolchecks.ts
+function isVercelTool(tool) {
+  return !!(tool && !(tool instanceof Tool) && "parameters" in tool);
+}
+
+export { Tool, createTool, isVercelTool };