@mastra/core 0.2.0-alpha.98 → 0.2.0

package/dist/{chunk-42DYOLDV.js → chunk-MEISIZMP.js}

@@ -1,17 +1,16 @@
-import { createTool } from './chunk-VOUPGVRD.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { createTool } from './chunk-3HBFW3Q7.js';
 import { z } from 'zod';
 
 // src/integration/integration.ts
-var _Integration = class _Integration {
+var Integration = class {
+  name = "Integration";
+  workflows;
   constructor() {
-    __publicField(this, "name", "Integration");
-    __publicField(this, "workflows");
     this.workflows = {};
   }
   /**
-  * Workflows
-  */
+   * Workflows
+   */
   registerWorkflow(name, fn) {
     if (this.workflows[name]) {
       throw new Error(`Sync function "${name}" already registered`);
@@ -32,8 +31,8 @@ var _Integration = class _Integration {
     return this.workflows;
   }
   /**
-  * TOOLS
-  */
+   * TOOLS
+   */
   getStaticTools(_params) {
     throw new Error("Method not implemented.");
   }
@@ -44,11 +43,9 @@ var _Integration = class _Integration {
     throw new Error("Method not implemented");
   }
 };
-__name(_Integration, "Integration");
-var Integration = _Integration;
-var _OpenAPIToolset = class _OpenAPIToolset {
+var OpenAPIToolset = class {
+  authType = "API_KEY";
   constructor() {
-    __publicField(this, "authType", "API_KEY");
   }
   get toolSchemas() {
     return {};
@@ -74,23 +71,18 @@ var _OpenAPIToolset = class _OpenAPIToolset {
         inputSchema: schemas[key] || z.object({}),
         description: comment || fallbackComment,
         // documentation: doc || fallbackComment,
-        execute: /* @__PURE__ */ __name(async ({ context }) => {
+        execute: async ({ context }) => {
           const client2 = await this.getApiClient();
           const value = client2[key];
           return value({
             ...context
           });
-        }, "execute")
+        }
       });
-      return {
-        ...acc,
-        [key]: tool
-      };
+      return { ...acc, [key]: tool };
     }, {});
     return tools;
   }
 };
-__name(_OpenAPIToolset, "OpenAPIToolset");
-var OpenAPIToolset = _OpenAPIToolset;
 
 export { Integration, OpenAPIToolset };

package/dist/chunk-MLWGYRJR.js

@@ -0,0 +1,87 @@
+// src/eval/metric.ts
+var Metric = class {
+};
+
+// 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, Metric, executeHook, registerHook };

package/dist/{chunk-ICMEXHKD.js → chunk-O2VP5JBC.js}

@@ -1,8 +1,8 @@
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
 import pino from 'pino';
 import pretty from 'pino-pretty';
 import { Transform } from 'stream';
 
+// src/logger/index.ts
 var RegisteredLogger = {
   AGENT: "AGENT",
   WORKFLOW: "WORKFLOW",
@@ -22,7 +22,7 @@ var LogLevel = {
   ERROR: "error",
   NONE: "silent"
 };
-var _LoggerTransport = class _LoggerTransport extends Transform {
+var LoggerTransport = class extends Transform {
   async getLogsByRunId({ runId }) {
     console.log(runId);
     return [];
@@ -31,41 +31,42 @@ var _LoggerTransport = class _LoggerTransport extends Transform {
     return [];
   }
 };
-__name(_LoggerTransport, "LoggerTransport");
-var LoggerTransport = _LoggerTransport;
-var _Logger = class _Logger {
+var Logger = class {
+  logger;
+  transports;
   constructor(options = {}) {
-    __publicField(this, "logger");
-    __publicField(this, "transports");
     this.transports = options.transports || {};
     const transportsAry = Object.entries(this.transports);
-    this.logger = pino({
-      name: options.name || "app",
-      level: options.level || LogLevel.INFO
-    }, options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty({
-      colorize: true,
-      levelFirst: true,
-      ignore: "pid,hostname",
-      colorizeObjects: true,
-      translateTime: "SYS:standard",
-      singleLine: false
-    }) : pino.multistream([
-      ...transportsAry.map(([_, transport]) => ({
-        stream: transport,
-        level: options.level || LogLevel.INFO
-      })),
+    this.logger = pino(
       {
-        stream: pretty({
-          colorize: true,
-          levelFirst: true,
-          ignore: "pid,hostname",
-          colorizeObjects: true,
-          translateTime: "SYS:standard",
-          singleLine: false
-        }),
+        name: options.name || "app",
         level: options.level || LogLevel.INFO
-      }
-    ]));
+      },
+      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty({
+        colorize: true,
+        levelFirst: true,
+        ignore: "pid,hostname",
+        colorizeObjects: true,
+        translateTime: "SYS:standard",
+        singleLine: false
+      }) : pino.multistream([
+        ...transportsAry.map(([_, transport]) => ({
+          stream: transport,
+          level: options.level || LogLevel.INFO
+        })),
+        {
+          stream: pretty({
+            colorize: true,
+            levelFirst: true,
+            ignore: "pid,hostname",
+            colorizeObjects: true,
+            translateTime: "SYS:standard",
+            singleLine: false
+          }),
+          level: options.level || LogLevel.INFO
+        }
+      ])
+    );
   }
   debug(message, args = {}) {
     this.logger.debug(args, message);
@@ -82,13 +83,13 @@ var _Logger = class _Logger {
   // Stream creation for process output handling
   createStream() {
     return new Transform({
-      transform: /* @__PURE__ */ __name((chunk, _encoding, callback) => {
+      transform: (chunk, _encoding, callback) => {
         const line = chunk.toString().trim();
         if (line) {
           this.info(line);
         }
         callback(null, chunk);
-      }, "transform")
+      }
     });
   }
   async getLogs(transportId) {
@@ -98,20 +99,15 @@ var _Logger = class _Logger {
     return this.transports[transportId].getLogs();
   }
   async getLogsByRunId({ runId, transportId }) {
-    return this.transports[transportId]?.getLogsByRunId({
-      runId
-    });
+    return this.transports[transportId]?.getLogsByRunId({ runId });
   }
 };
-__name(_Logger, "Logger");
-var Logger = _Logger;
 function createLogger(options) {
   return new Logger(options);
 }
-__name(createLogger, "createLogger");
-var _MultiLogger = class _MultiLogger {
+var MultiLogger = class {
+  loggers;
   constructor(loggers) {
-    __publicField(this, "loggers");
     this.loggers = loggers;
   }
   debug(message, ...args) {
@@ -127,23 +123,20 @@ var _MultiLogger = class _MultiLogger {
     this.loggers.forEach((logger) => logger.error(message, ...args));
   }
 };
-__name(_MultiLogger, "MultiLogger");
-var MultiLogger = _MultiLogger;
 function combineLoggers(loggers) {
   return new MultiLogger(loggers);
 }
-__name(combineLoggers, "combineLoggers");
 var noopLogger = {
-  debug: /* @__PURE__ */ __name(() => {
-  }, "debug"),
-  info: /* @__PURE__ */ __name(() => {
-  }, "info"),
-  warn: /* @__PURE__ */ __name(() => {
-  }, "warn"),
-  error: /* @__PURE__ */ __name(() => {
-  }, "error"),
-  cleanup: /* @__PURE__ */ __name(async () => {
-  }, "cleanup")
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  cleanup: async () => {
+  }
 };
 
 export { LogLevel, Logger, LoggerTransport, MultiLogger, RegisteredLogger, combineLoggers, createLogger, noopLogger };