@scoutqa/mastra-core 0.24.6-fork.1

package/dist/chunk-TSNDVBUU.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+// 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";
+  AvailableHooks2["ON_SCORER_RUN"] = "onScorerRun";
+  return AvailableHooks2;
+})(AvailableHooks || {});
+var hooks = mitt();
+function registerHook(hook, action) {
+  hooks.on(hook, action);
+}
+function executeHook(hook, data) {
+  setImmediate(() => {
+    hooks.emit(hook, data);
+  });
+}
+
+exports.AvailableHooks = AvailableHooks;
+exports.executeHook = executeHook;
+exports.registerHook = registerHook;
+//# sourceMappingURL=chunk-TSNDVBUU.cjs.map
+//# sourceMappingURL=chunk-TSNDVBUU.cjs.map

package/dist/chunk-TSNDVBUU.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/mitt.ts","../src/hooks/index.ts"],"names":["AvailableHooks"],"mappings":";;;AAqCe,SAAR,KACL,GAAA,EACiB;AAEjB,EAAA,GAAA,GAAM,GAAA,wBAAW,GAAA,EAAI;AAErB,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA,IAIL,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,EAAA,CAA6B,MAAW,OAAA,EAA8B;AACpE,MAAA,MAAM,QAAA,GAAmD,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AACtE,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,QAAA,CAAS,KAAK,OAAO,CAAA;AAAA,MACvB,CAAA,MAAO;AACL,QAAA,GAAA,CAAK,GAAA,CAAI,IAAA,EAAM,CAAC,OAAO,CAA2C,CAAA;AAAA,MACpE;AAAA,IACF,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASA,GAAA,CAA8B,MAAW,OAAA,EAA+B;AACtE,MAAA,MAAM,QAAA,GAAmD,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AACtE,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,IAAI,OAAA,EAAS;AACX,UAAA,QAAA,CAAS,OAAO,QAAA,CAAS,OAAA,CAAQ,OAAO,CAAA,KAAM,GAAG,CAAC,CAAA;AAAA,QACpD,CAAA,MAAO;AACL,UAAA,GAAA,CAAK,GAAA,CAAI,IAAA,EAAM,EAAE,CAAA;AAAA,QACnB;AAAA,MACF;AAAA,IACF,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAYA,IAAA,CAA+B,MAAW,GAAA,EAAmB;AAC3D,MAAA,IAAI,QAAA,GAAW,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AAC5B,MAAA,IAAI,QAAA,EAAU;AACZ,QAAC,QAAA,CAAoD,KAAA,EAAM,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW;AAC1E,UAAA,OAAA,CAAQ,GAAI,CAAA;AAAA,QACd,CAAC,CAAA;AAAA,MACH;AAEA,MAAA,QAAA,GAAW,GAAA,CAAK,IAAI,GAAG,CAAA;AACvB,MAAA,IAAI,QAAA,EAAU;AACZ,QAAC,QAAA,CAA8C,KAAA,EAAM,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW;AACpE,UAAA,OAAA,CAAQ,MAAM,GAAI,CAAA;AAAA,QACpB,CAAC,CAAA;AAAA,MACH;AAAA,IACF;AAAA,GACF;AACF;;;ACrGO,IAAK,cAAA,qBAAAA,eAAAA,KAAL;AACL,EAAAA,gBAAA,eAAA,CAAA,GAAgB,cAAA;AAChB,EAAAA,gBAAA,eAAA,CAAA,GAAgB,cAAA;AAChB,EAAAA,gBAAA,eAAA,CAAA,GAAgB,aAAA;AAHN,EAAA,OAAAA,eAAAA;AAAA,CAAA,EAAA,cAAA,IAAA,EAAA;AAMZ,IAAM,QAAQ,IAAA,EAAK;AA0BZ,SAAS,YAAA,CAAa,MAA2B,MAAA,EAA4B;AAClF,EAAA,KAAA,CAAM,EAAA,CAAG,MAAM,MAAM,CAAA;AACvB;AAKO,SAAS,WAAA,CAAY,MAA2B,IAAA,EAAqB;AAE1E,EAAA,YAAA,CAAa,MAAM;AACjB,IAAA,KAAA,CAAM,IAAA,CAAK,MAAM,IAAI,CAAA;AAAA,EACvB,CAAC,CAAA;AACH","file":"chunk-TSNDVBUU.cjs","sourcesContent":["// copied from https://github.com/developit/mitt\n\nexport type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | '*',\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n  all: EventHandlerMap<Events>;\n\n  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n  on(type: '*', handler: WildcardHandler<Events>): void;\n\n  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;\n  off(type: '*', handler: WildcardHandler<Events>): void;\n\n  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n  all?: EventHandlerMap<Events>,\n): Emitter<Events> {\n  type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;\n  all = all || new Map();\n\n  return {\n    /**\n     * A Map of event names to registered handler functions.\n     */\n    all,\n\n    /**\n     * Register an event handler for the given type.\n     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n     * @param {Function} handler Function to call in response to given event\n     * @memberOf mitt\n     */\n    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n      if (handlers) {\n        handlers.push(handler);\n      } else {\n        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n      }\n    },\n\n    /**\n     * Remove an event handler for the given type.\n     * If `handler` is omitted, all handlers of the given type are removed.\n     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n     * @param {Function} [handler] Handler function to remove\n     * @memberOf mitt\n     */\n    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n      if (handlers) {\n        if (handler) {\n          handlers.splice(handlers.indexOf(handler) >>> 0, 1);\n        } else {\n          all!.set(type, []);\n        }\n      }\n    },\n\n    /**\n     * Invoke all handlers for the given type.\n     * If present, `'*'` handlers are invoked after type-matched handlers.\n     *\n     * Note: Manually firing '*' handlers is not supported.\n     *\n     * @param {string|symbol} type The event type to invoke\n     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n     * @memberOf mitt\n     */\n    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n      let handlers = all!.get(type);\n      if (handlers) {\n        (handlers as EventHandlerList<Events[keyof Events]>).slice().map(handler => {\n          handler(evt!);\n        });\n      }\n\n      handlers = all!.get('*');\n      if (handlers) {\n        (handlers as WildCardEventHandlerList<Events>).slice().map(handler => {\n          handler(type, evt!);\n        });\n      }\n    },\n  };\n}\n","import type { Metric, MetricResult } from '../eval/metric';\nimport type { TestInfo } from '../eval/types';\nimport type { ScoringHookInput } from '../scores';\n\nimport mitt from './mitt';\nimport type { Handler } from './mitt';\n\nexport enum AvailableHooks {\n  ON_EVALUATION = 'onEvaluation',\n  ON_GENERATION = 'onGeneration',\n  ON_SCORER_RUN = 'onScorerRun',\n}\n\nconst hooks = mitt();\n\ntype EvaluationHookData = {\n  input: string;\n  output: string;\n  result: MetricResult;\n  agentName: string;\n  metricName: string;\n  instructions: string;\n  runId: string;\n  globalRunId: string;\n  testInfo?: TestInfo;\n};\n\ntype GenerationHookData = {\n  input: string;\n  output: string;\n  metric: Metric;\n  runId: string;\n  agentName: string;\n  instructions: string;\n};\n\nexport function registerHook(hook: AvailableHooks.ON_EVALUATION, action: Handler<EvaluationHookData>): void;\nexport function registerHook(hook: AvailableHooks.ON_GENERATION, action: Handler<GenerationHookData>): void;\nexport function registerHook(hook: AvailableHooks.ON_SCORER_RUN, action: Handler<ScoringHookInput>): void;\nexport function registerHook(hook: `${AvailableHooks}`, action: Handler<any>): void {\n  hooks.on(hook, action);\n}\n\nexport function executeHook(hook: AvailableHooks.ON_EVALUATION, action: EvaluationHookData): void;\nexport function executeHook(hook: AvailableHooks.ON_GENERATION, action: GenerationHookData): void;\nexport function executeHook(hook: AvailableHooks.ON_SCORER_RUN, action: ScoringHookInput): void;\nexport function executeHook(hook: `${AvailableHooks}`, data: unknown): void {\n  // do not block the main thread\n  setImmediate(() => {\n    hooks.emit(hook, data);\n  });\n}\n"]}

package/dist/chunk-TTELJD4F.js

@@ -0,0 +1,86 @@
+// 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";
+  AvailableHooks2["ON_SCORER_RUN"] = "onScorerRun";
+  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 };
+//# sourceMappingURL=chunk-TTELJD4F.js.map
+//# sourceMappingURL=chunk-TTELJD4F.js.map

package/dist/chunk-TTELJD4F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/mitt.ts","../src/hooks/index.ts"],"names":["AvailableHooks"],"mappings":";AAqCe,SAAR,KACL,GAAA,EACiB;AAEjB,EAAA,GAAA,GAAM,GAAA,wBAAW,GAAA,EAAI;AAErB,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA,IAIL,GAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,EAAA,CAA6B,MAAW,OAAA,EAA8B;AACpE,MAAA,MAAM,QAAA,GAAmD,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AACtE,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,QAAA,CAAS,KAAK,OAAO,CAAA;AAAA,MACvB,CAAA,MAAO;AACL,QAAA,GAAA,CAAK,GAAA,CAAI,IAAA,EAAM,CAAC,OAAO,CAA2C,CAAA;AAAA,MACpE;AAAA,IACF,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IASA,GAAA,CAA8B,MAAW,OAAA,EAA+B;AACtE,MAAA,MAAM,QAAA,GAAmD,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AACtE,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,IAAI,OAAA,EAAS;AACX,UAAA,QAAA,CAAS,OAAO,QAAA,CAAS,OAAA,CAAQ,OAAO,CAAA,KAAM,GAAG,CAAC,CAAA;AAAA,QACpD,CAAA,MAAO;AACL,UAAA,GAAA,CAAK,GAAA,CAAI,IAAA,EAAM,EAAE,CAAA;AAAA,QACnB;AAAA,MACF;AAAA,IACF,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAYA,IAAA,CAA+B,MAAW,GAAA,EAAmB;AAC3D,MAAA,IAAI,QAAA,GAAW,GAAA,CAAK,GAAA,CAAI,IAAI,CAAA;AAC5B,MAAA,IAAI,QAAA,EAAU;AACZ,QAAC,QAAA,CAAoD,KAAA,EAAM,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW;AAC1E,UAAA,OAAA,CAAQ,GAAI,CAAA;AAAA,QACd,CAAC,CAAA;AAAA,MACH;AAEA,MAAA,QAAA,GAAW,GAAA,CAAK,IAAI,GAAG,CAAA;AACvB,MAAA,IAAI,QAAA,EAAU;AACZ,QAAC,QAAA,CAA8C,KAAA,EAAM,CAAE,GAAA,CAAI,CAAA,OAAA,KAAW;AACpE,UAAA,OAAA,CAAQ,MAAM,GAAI,CAAA;AAAA,QACpB,CAAC,CAAA;AAAA,MACH;AAAA,IACF;AAAA,GACF;AACF;;;ACrGO,IAAK,cAAA,qBAAAA,eAAAA,KAAL;AACL,EAAAA,gBAAA,eAAA,CAAA,GAAgB,cAAA;AAChB,EAAAA,gBAAA,eAAA,CAAA,GAAgB,cAAA;AAChB,EAAAA,gBAAA,eAAA,CAAA,GAAgB,aAAA;AAHN,EAAA,OAAAA,eAAAA;AAAA,CAAA,EAAA,cAAA,IAAA,EAAA;AAMZ,IAAM,QAAQ,IAAA,EAAK;AA0BZ,SAAS,YAAA,CAAa,MAA2B,MAAA,EAA4B;AAClF,EAAA,KAAA,CAAM,EAAA,CAAG,MAAM,MAAM,CAAA;AACvB;AAKO,SAAS,WAAA,CAAY,MAA2B,IAAA,EAAqB;AAE1E,EAAA,YAAA,CAAa,MAAM;AACjB,IAAA,KAAA,CAAM,IAAA,CAAK,MAAM,IAAI,CAAA;AAAA,EACvB,CAAC,CAAA;AACH","file":"chunk-TTELJD4F.js","sourcesContent":["// copied from https://github.com/developit/mitt\n\nexport type EventType = string | symbol;\n\n// An event handler can take an optional event argument\n// and should not return a value\nexport type Handler<T = unknown> = (event: T) => void;\nexport type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;\n\n// An array of all currently registered event handlers for a type\nexport type EventHandlerList<T = unknown> = Array<Handler<T>>;\nexport type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;\n\n// A map of event types and their corresponding event handlers.\nexport type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<\n  keyof Events | '*',\n  EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>\n>;\n\nexport interface Emitter<Events extends Record<EventType, unknown>> {\n  all: EventHandlerMap<Events>;\n\n  on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;\n  on(type: '*', handler: WildcardHandler<Events>): void;\n\n  off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;\n  off(type: '*', handler: WildcardHandler<Events>): void;\n\n  emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;\n  emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;\n}\n\n/**\n * Mitt: Tiny (~200b) functional event emitter / pubsub.\n * @name mitt\n * @returns {Mitt}\n */\nexport default function mitt<Events extends Record<EventType, unknown>>(\n  all?: EventHandlerMap<Events>,\n): Emitter<Events> {\n  type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;\n  all = all || new Map();\n\n  return {\n    /**\n     * A Map of event names to registered handler functions.\n     */\n    all,\n\n    /**\n     * Register an event handler for the given type.\n     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events\n     * @param {Function} handler Function to call in response to given event\n     * @memberOf mitt\n     */\n    on<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {\n      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n      if (handlers) {\n        handlers.push(handler);\n      } else {\n        all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);\n      }\n    },\n\n    /**\n     * Remove an event handler for the given type.\n     * If `handler` is omitted, all handlers of the given type are removed.\n     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)\n     * @param {Function} [handler] Handler function to remove\n     * @memberOf mitt\n     */\n    off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {\n      const handlers: Array<GenericEventHandler> | undefined = all!.get(type);\n      if (handlers) {\n        if (handler) {\n          handlers.splice(handlers.indexOf(handler) >>> 0, 1);\n        } else {\n          all!.set(type, []);\n        }\n      }\n    },\n\n    /**\n     * Invoke all handlers for the given type.\n     * If present, `'*'` handlers are invoked after type-matched handlers.\n     *\n     * Note: Manually firing '*' handlers is not supported.\n     *\n     * @param {string|symbol} type The event type to invoke\n     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler\n     * @memberOf mitt\n     */\n    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {\n      let handlers = all!.get(type);\n      if (handlers) {\n        (handlers as EventHandlerList<Events[keyof Events]>).slice().map(handler => {\n          handler(evt!);\n        });\n      }\n\n      handlers = all!.get('*');\n      if (handlers) {\n        (handlers as WildCardEventHandlerList<Events>).slice().map(handler => {\n          handler(type, evt!);\n        });\n      }\n    },\n  };\n}\n","import type { Metric, MetricResult } from '../eval/metric';\nimport type { TestInfo } from '../eval/types';\nimport type { ScoringHookInput } from '../scores';\n\nimport mitt from './mitt';\nimport type { Handler } from './mitt';\n\nexport enum AvailableHooks {\n  ON_EVALUATION = 'onEvaluation',\n  ON_GENERATION = 'onGeneration',\n  ON_SCORER_RUN = 'onScorerRun',\n}\n\nconst hooks = mitt();\n\ntype EvaluationHookData = {\n  input: string;\n  output: string;\n  result: MetricResult;\n  agentName: string;\n  metricName: string;\n  instructions: string;\n  runId: string;\n  globalRunId: string;\n  testInfo?: TestInfo;\n};\n\ntype GenerationHookData = {\n  input: string;\n  output: string;\n  metric: Metric;\n  runId: string;\n  agentName: string;\n  instructions: string;\n};\n\nexport function registerHook(hook: AvailableHooks.ON_EVALUATION, action: Handler<EvaluationHookData>): void;\nexport function registerHook(hook: AvailableHooks.ON_GENERATION, action: Handler<GenerationHookData>): void;\nexport function registerHook(hook: AvailableHooks.ON_SCORER_RUN, action: Handler<ScoringHookInput>): void;\nexport function registerHook(hook: `${AvailableHooks}`, action: Handler<any>): void {\n  hooks.on(hook, action);\n}\n\nexport function executeHook(hook: AvailableHooks.ON_EVALUATION, action: EvaluationHookData): void;\nexport function executeHook(hook: AvailableHooks.ON_GENERATION, action: GenerationHookData): void;\nexport function executeHook(hook: AvailableHooks.ON_SCORER_RUN, action: ScoringHookInput): void;\nexport function executeHook(hook: `${AvailableHooks}`, data: unknown): void {\n  // do not block the main thread\n  setImmediate(() => {\n    hooks.emit(hook, data);\n  });\n}\n"]}

package/dist/chunk-TX4TTPYJ.cjs

@@ -0,0 +1,436 @@
+'use strict';
+
+var chunk4R2TBRS7_cjs = require('./chunk-4R2TBRS7.cjs');
+var chunk5NTO7S5I_cjs = require('./chunk-5NTO7S5I.cjs');
+var chunk6VOPKVYH_cjs = require('./chunk-6VOPKVYH.cjs');
+
+// src/storage/base.ts
+function ensureDate(date) {
+  if (!date) return void 0;
+  return date instanceof Date ? date : new Date(date);
+}
+function serializeDate(date) {
+  if (!date) return void 0;
+  const dateObj = ensureDate(date);
+  return dateObj?.toISOString();
+}
+function resolveMessageLimit({
+  last,
+  defaultLimit
+}) {
+  if (typeof last === "number") return Math.max(0, last);
+  if (last === false) return 0;
+  return defaultLimit;
+}
+var MastraStorage = class extends chunk6VOPKVYH_cjs.MastraBase {
+  /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
+  static TABLE_WORKFLOW_SNAPSHOT = chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT;
+  /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
+  static TABLE_EVALS = chunk4R2TBRS7_cjs.TABLE_EVALS;
+  /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
+  static TABLE_MESSAGES = chunk4R2TBRS7_cjs.TABLE_MESSAGES;
+  /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
+  static TABLE_THREADS = chunk4R2TBRS7_cjs.TABLE_THREADS;
+  /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
+  static TABLE_TRACES = chunk4R2TBRS7_cjs.TABLE_TRACES;
+  hasInitialized = null;
+  shouldCacheInit = true;
+  stores;
+  constructor({ name }) {
+    super({
+      component: "STORAGE",
+      name
+    });
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: false,
+      resourceWorkingMemory: false,
+      hasColumn: false,
+      createTable: false,
+      deleteMessages: false,
+      aiTracing: false,
+      indexManagement: false,
+      getScoresBySpan: false
+    };
+  }
+  ensureDate(date) {
+    return ensureDate(date);
+  }
+  serializeDate(date) {
+    return serializeDate(date);
+  }
+  /**
+   * Resolves limit for how many messages to fetch
+   *
+   * @param last The number of messages to fetch
+   * @param defaultLimit The default limit to use if last is not provided
+   * @returns The resolved limit
+   */
+  resolveMessageLimit({
+    last,
+    defaultLimit
+  }) {
+    return resolveMessageLimit({ last, defaultLimit });
+  }
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "float":
+        return "FLOAT";
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "BIGINT";
+      case "jsonb":
+        return "JSONB";
+      default:
+        return "TEXT";
+    }
+  }
+  getDefaultValue(type) {
+    switch (type) {
+      case "text":
+      case "uuid":
+        return "DEFAULT ''";
+      case "timestamp":
+        return "DEFAULT '1970-01-01 00:00:00'";
+      case "integer":
+      case "float":
+      case "bigint":
+        return "DEFAULT 0";
+      case "jsonb":
+        return "DEFAULT '{}'";
+      default:
+        return "DEFAULT ''";
+    }
+  }
+  batchTraceInsert({ records }) {
+    if (this.stores?.traces) {
+      return this.stores.traces.batchTraceInsert({ records });
+    }
+    return this.batchInsert({ tableName: chunk4R2TBRS7_cjs.TABLE_TRACES, records });
+  }
+  async getResourceById(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async saveResource(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async updateResource(_) {
+    throw new Error(
+      `Resource working memory is not supported by this storage adapter (${this.constructor.name}). Supported storage adapters: LibSQL (@mastra/libsql), PostgreSQL (@mastra/pg), Upstash (@mastra/upstash). To use per-resource working memory, switch to one of these supported storage adapters.`
+    );
+  }
+  async deleteMessages(_messageIds) {
+    throw new Error(
+      `Message deletion is not supported by this storage adapter (${this.constructor.name}). The deleteMessages method needs to be implemented in the storage adapter.`
+    );
+  }
+  async init() {
+    if (this.shouldCacheInit && await this.hasInitialized) {
+      return;
+    }
+    const tableCreationTasks = [
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT]
+      }),
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_EVALS,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_EVALS]
+      }),
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_THREADS,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_THREADS]
+      }),
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_MESSAGES,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_MESSAGES]
+      }),
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_TRACES,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_TRACES]
+      }),
+      this.createTable({
+        tableName: chunk4R2TBRS7_cjs.TABLE_SCORERS,
+        schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_SCORERS]
+      })
+    ];
+    if (this.supports.resourceWorkingMemory) {
+      tableCreationTasks.push(
+        this.createTable({
+          tableName: chunk4R2TBRS7_cjs.TABLE_RESOURCES,
+          schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_RESOURCES]
+        })
+      );
+    }
+    if (this.supports.aiTracing) {
+      tableCreationTasks.push(
+        this.createTable({
+          tableName: chunk4R2TBRS7_cjs.TABLE_AI_SPANS,
+          schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_AI_SPANS]
+        })
+      );
+    }
+    this.hasInitialized = Promise.all(tableCreationTasks).then(() => true);
+    await this.hasInitialized;
+    await this?.alterTable?.({
+      tableName: chunk4R2TBRS7_cjs.TABLE_MESSAGES,
+      schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_MESSAGES],
+      ifNotExists: ["resourceId"]
+    });
+    await this?.alterTable?.({
+      tableName: chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT,
+      schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT],
+      ifNotExists: ["resourceId"]
+    });
+    await this?.alterTable?.({
+      tableName: chunk4R2TBRS7_cjs.TABLE_SCORERS,
+      schema: chunk4R2TBRS7_cjs.TABLE_SCHEMAS[chunk4R2TBRS7_cjs.TABLE_SCORERS],
+      ifNotExists: ["spanId"]
+    });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    resourceId,
+    snapshot
+  }) {
+    await this.init();
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      resourceId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.insert({
+      tableName: chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT,
+      record: data
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    if (!this.hasInitialized) {
+      await this.init();
+    }
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.load({
+      tableName: chunk4R2TBRS7_cjs.TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination: _pagination
+  }) {
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "SCORES_STORAGE_GET_SCORES_BY_SPAN_NOT_IMPLEMENTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      details: { traceId, spanId }
+    });
+  }
+  /**
+   * OBSERVABILITY
+   */
+  /**
+   * Provides hints for AI tracing strategy selection by the DefaultExporter.
+   * Storage adapters can override this to specify their preferred and supported strategies.
+   */
+  get aiTracingStrategy() {
+    if (this.stores?.observability) {
+      return this.stores.observability.aiTracingStrategy;
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_TRACING_STRATEGY_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Creates a single AI span record in the storage provider.
+   */
+  async createAISpan(span) {
+    if (this.stores?.observability) {
+      return this.stores.observability.createAISpan(span);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_CREATE_AI_SPAN_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Updates a single AI span with partial data. Primarily used for realtime trace creation.
+   */
+  async updateAISpan(params) {
+    if (this.stores?.observability) {
+      return this.stores.observability.updateAISpan(params);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_UPDATE_AI_SPAN_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Retrieves a single AI trace with all its associated spans.
+   */
+  async getAITrace(traceId) {
+    if (this.stores?.observability) {
+      return this.stores.observability.getAITrace(traceId);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_GET_AI_TRACE_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Retrieves a paginated list of AI traces with optional filtering.
+   */
+  async getAITracesPaginated(args) {
+    if (this.stores?.observability) {
+      return this.stores.observability.getAITracesPaginated(args);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_GET_AI_TRACES_PAGINATED_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Creates multiple AI spans in a single batch.
+   */
+  async batchCreateAISpans(args) {
+    if (this.stores?.observability) {
+      return this.stores.observability.batchCreateAISpans(args);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_BATCH_CREATE_AI_SPANS_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Updates multiple AI spans in a single batch.
+   */
+  async batchUpdateAISpans(args) {
+    if (this.stores?.observability) {
+      return this.stores.observability.batchUpdateAISpans(args);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_BATCH_UPDATE_AI_SPANS_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Deletes multiple AI traces and all their associated spans in a single batch operation.
+   */
+  async batchDeleteAITraces(args) {
+    if (this.stores?.observability) {
+      return this.stores.observability.batchDeleteAITraces(args);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_BATCH_DELETE_AI_TRACES_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `AI tracing is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * DATABASE INDEX MANAGEMENT
+   * These methods delegate to the operations store for index management.
+   * Storage adapters that support indexes should implement these in their operations class.
+   */
+  /**
+   * Creates a database index on specified columns
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async createIndex(options) {
+    if (this.stores?.operations) {
+      return this.stores.operations.createIndex(options);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_CREATE_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Drops a database index by name
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async dropIndex(indexName) {
+    if (this.stores?.operations) {
+      return this.stores.operations.dropIndex(indexName);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_DROP_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Lists database indexes for a table or all tables
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async listIndexes(tableName) {
+    if (this.stores?.operations) {
+      return this.stores.operations.listIndexes(tableName);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_LIST_INDEXES_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Gets detailed statistics for a specific index
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async describeIndex(indexName) {
+    if (this.stores?.operations) {
+      return this.stores.operations.describeIndex(indexName);
+    }
+    throw new chunk5NTO7S5I_cjs.MastraError({
+      id: "MASTRA_STORAGE_DESCRIBE_INDEX_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Index management is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+};
+
+exports.MastraStorage = MastraStorage;
+exports.ensureDate = ensureDate;
+exports.resolveMessageLimit = resolveMessageLimit;
+exports.serializeDate = serializeDate;
+//# sourceMappingURL=chunk-TX4TTPYJ.cjs.map
+//# sourceMappingURL=chunk-TX4TTPYJ.cjs.map