@mastra/core 0.0.0-commonjs-20250227130920

package/dist/filter/index.d.ts

@@ -0,0 +1,90 @@
+type BasicOperator = '$eq' | '$ne';
+type NumericOperator = '$gt' | '$gte' | '$lt' | '$lte';
+type LogicalOperator = '$and' | '$not' | '$nor' | '$or';
+type ArrayOperator = '$all' | '$in' | '$nin' | '$elemMatch';
+type ElementOperator = '$exists';
+type RegexOperator = '$regex' | '$options';
+type QueryOperator = BasicOperator | NumericOperator | LogicalOperator | ArrayOperator | ElementOperator | RegexOperator;
+type OperatorCondition = {
+    [K in QueryOperator]?: any;
+};
+type FieldCondition = OperatorCondition | any;
+type Filter = {
+    [field: string]: FieldCondition | Filter;
+};
+type OperatorSupport = {
+    logical?: LogicalOperator[];
+    array?: ArrayOperator[];
+    basic?: BasicOperator[];
+    numeric?: NumericOperator[];
+    element?: ElementOperator[];
+    regex?: RegexOperator[];
+    custom?: string[];
+};
+declare abstract class BaseFilterTranslator {
+    abstract translate(filter: Filter): unknown;
+    /**
+     * Operator type checks
+     */
+    protected isOperator(key: string): key is QueryOperator;
+    protected static readonly BASIC_OPERATORS: BasicOperator[];
+    protected static readonly NUMERIC_OPERATORS: NumericOperator[];
+    protected static readonly ARRAY_OPERATORS: ArrayOperator[];
+    protected static readonly LOGICAL_OPERATORS: LogicalOperator[];
+    protected static readonly ELEMENT_OPERATORS: ElementOperator[];
+    protected static readonly REGEX_OPERATORS: RegexOperator[];
+    static readonly DEFAULT_OPERATORS: {
+        logical: LogicalOperator[];
+        basic: BasicOperator[];
+        numeric: NumericOperator[];
+        array: ArrayOperator[];
+        element: "$exists"[];
+        regex: RegexOperator[];
+    };
+    protected isLogicalOperator(key: string): key is LogicalOperator;
+    protected isBasicOperator(key: string): key is BasicOperator;
+    protected isNumericOperator(key: string): key is NumericOperator;
+    protected isArrayOperator(key: string): key is ArrayOperator;
+    protected isElementOperator(key: string): key is ElementOperator;
+    protected isRegexOperator(key: string): key is RegexOperator;
+    protected isFieldOperator(key: string): key is QueryOperator;
+    protected isCustomOperator(key: string): boolean;
+    protected getSupportedOperators(): OperatorSupport;
+    protected isValidOperator(key: string): boolean;
+    /**
+     * Value normalization for comparison operators
+     */
+    protected normalizeComparisonValue(value: any): any;
+    /**
+     * Helper method to simulate $all operator using $and + $eq when needed.
+     * Some vector stores don't support $all natively.
+     */
+    protected simulateAllOperator(field: string, values: any[]): Filter;
+    /**
+     * Utility functions for type checking
+     */
+    protected isPrimitive(value: any): boolean;
+    protected isRegex(value: any): boolean;
+    protected isEmpty(obj: any): boolean;
+    protected static readonly ErrorMessages: {
+        readonly UNSUPPORTED_OPERATOR: (op: string) => string;
+        readonly INVALID_LOGICAL_OPERATOR_LOCATION: (op: string, path: string) => string;
+        readonly NOT_REQUIRES_OBJECT: "$not operator requires an object";
+        readonly NOT_CANNOT_BE_EMPTY: "$not operator cannot be empty";
+        readonly INVALID_LOGICAL_OPERATOR_CONTENT: (path: string) => string;
+        readonly INVALID_TOP_LEVEL_OPERATOR: (op: string) => string;
+        readonly ELEM_MATCH_REQUIRES_OBJECT: "$elemMatch requires an object with conditions";
+    };
+    /**
+     * Helper to handle array value normalization consistently
+     */
+    protected normalizeArrayValues(values: any[]): any[];
+    protected validateFilter(filter: Filter): void;
+    /**
+     * Validates if a filter structure is supported by the specific vector DB
+     * and returns detailed validation information.
+     */
+    private validateFilterSupport;
+}
+
+export { type ArrayOperator, BaseFilterTranslator, type BasicOperator, type ElementOperator, type FieldCondition, type Filter, type LogicalOperator, type NumericOperator, type OperatorCondition, type OperatorSupport, type QueryOperator, type RegexOperator };

package/dist/filter/index.js

@@ -0,0 +1 @@
+export { BaseFilterTranslator } from '../chunk-SIFBBGY6.js';

package/dist/hooks/index.cjs

@@ -0,0 +1,87 @@
+'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";
+  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;

package/dist/hooks/index.d.cts

@@ -0,0 +1,33 @@
+import { M as MetricResult, T as TestInfo, a as Metric } from '../types-m9RryK9a.cjs';
+
+type Handler<T = unknown> = (event: T) => void;
+
+declare enum AvailableHooks {
+    ON_EVALUATION = "onEvaluation",
+    ON_GENERATION = "onGeneration"
+}
+type EvaluationHookData = {
+    input: string;
+    output: string;
+    result: MetricResult;
+    agentName: string;
+    metricName: string;
+    instructions: string;
+    runId: string;
+    globalRunId: string;
+    testInfo?: TestInfo;
+};
+type GenerationHookData = {
+    input: string;
+    output: string;
+    metric: Metric;
+    runId: string;
+    agentName: string;
+    instructions: string;
+};
+declare function registerHook(hook: AvailableHooks.ON_EVALUATION, action: Handler<EvaluationHookData>): void;
+declare function registerHook(hook: AvailableHooks.ON_GENERATION, action: Handler<GenerationHookData>): void;
+declare function executeHook(hook: AvailableHooks.ON_EVALUATION, action: EvaluationHookData): void;
+declare function executeHook(hook: AvailableHooks.ON_GENERATION, action: GenerationHookData): void;
+
+export { AvailableHooks, executeHook, registerHook };

package/dist/hooks/index.d.ts

@@ -0,0 +1,33 @@
+import { M as MetricResult, T as TestInfo, a as Metric } from '../types-m9RryK9a.js';
+
+type Handler<T = unknown> = (event: T) => void;
+
+declare enum AvailableHooks {
+    ON_EVALUATION = "onEvaluation",
+    ON_GENERATION = "onGeneration"
+}
+type EvaluationHookData = {
+    input: string;
+    output: string;
+    result: MetricResult;
+    agentName: string;
+    metricName: string;
+    instructions: string;
+    runId: string;
+    globalRunId: string;
+    testInfo?: TestInfo;
+};
+type GenerationHookData = {
+    input: string;
+    output: string;
+    metric: Metric;
+    runId: string;
+    agentName: string;
+    instructions: string;
+};
+declare function registerHook(hook: AvailableHooks.ON_EVALUATION, action: Handler<EvaluationHookData>): void;
+declare function registerHook(hook: AvailableHooks.ON_GENERATION, action: Handler<GenerationHookData>): void;
+declare function executeHook(hook: AvailableHooks.ON_EVALUATION, action: EvaluationHookData): void;
+declare function executeHook(hook: AvailableHooks.ON_GENERATION, action: GenerationHookData): void;
+
+export { AvailableHooks, executeHook, registerHook };

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export { AvailableHooks, executeHook, registerHook } from '../chunk-BB4KXGBU.js';

package/dist/index-mKY1XrpK.d.cts

@@ -0,0 +1,90 @@
+import { Transform } from 'stream';
+import pino from 'pino';
+
+type RunStatus = 'created' | 'running' | 'completed' | 'failed';
+type Run = {
+    runId?: string;
+    runStatus?: RunStatus;
+};
+
+declare const RegisteredLogger: {
+    readonly AGENT: "AGENT";
+    readonly WORKFLOW: "WORKFLOW";
+    readonly LLM: "LLM";
+    readonly TTS: "TTS";
+    readonly VOICE: "VOICE";
+    readonly VECTOR: "VECTOR";
+    readonly BUNDLER: "BUNDLER";
+    readonly DEPLOYER: "DEPLOYER";
+    readonly MEMORY: "MEMORY";
+    readonly STORAGE: "STORAGE";
+    readonly EMBEDDINGS: "EMBEDDINGS";
+};
+type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
+declare const LogLevel: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+    readonly NONE: "silent";
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+interface BaseLogMessage extends Run {
+    msg: string;
+    level: number;
+    time: Date;
+    pid: number;
+    hostname: string;
+    name: string;
+}
+declare class LoggerTransport extends Transform {
+    constructor(opts?: any);
+    getLogsByRunId(_args: {
+        runId: string;
+    }): Promise<BaseLogMessage[]>;
+    getLogs(): Promise<BaseLogMessage[]>;
+}
+type TransportMap = Record<string, LoggerTransport>;
+declare class Logger {
+    protected logger: pino.Logger;
+    transports: TransportMap;
+    constructor(options?: {
+        name?: string;
+        level?: LogLevel;
+        transports?: TransportMap;
+        overrideDefaultTransports?: boolean;
+    });
+    debug(message: string, args?: Record<string, any>): void;
+    info(message: string, args?: Record<string, any>): void;
+    warn(message: string, args?: Record<string, any>): void;
+    error(message: string, args?: Record<string, any>): void;
+    createStream(): Transform;
+    getLogs(transportId: string): Promise<BaseLogMessage[]>;
+    getLogsByRunId({ runId, transportId }: {
+        transportId: string;
+        runId: string;
+    }): Promise<BaseLogMessage[] | undefined>;
+}
+declare function createLogger(options: {
+    name?: string;
+    level?: LogLevel;
+    transports?: TransportMap;
+}): Logger;
+declare class MultiLogger {
+    private loggers;
+    constructor(loggers: Logger[]);
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+declare function combineLoggers(loggers: Logger[]): MultiLogger;
+declare const noopLogger: {
+    debug: () => void;
+    info: () => void;
+    warn: () => void;
+    error: () => void;
+    cleanup: () => Promise<void>;
+};
+
+export { type BaseLogMessage as B, Logger as L, MultiLogger as M, RegisteredLogger as R, type TransportMap as T, LogLevel as a, LoggerTransport as b, combineLoggers as c, type Run as d, createLogger as e, noopLogger as n };

package/dist/index-mKY1XrpK.d.ts

@@ -0,0 +1,90 @@
+import { Transform } from 'stream';
+import pino from 'pino';
+
+type RunStatus = 'created' | 'running' | 'completed' | 'failed';
+type Run = {
+    runId?: string;
+    runStatus?: RunStatus;
+};
+
+declare const RegisteredLogger: {
+    readonly AGENT: "AGENT";
+    readonly WORKFLOW: "WORKFLOW";
+    readonly LLM: "LLM";
+    readonly TTS: "TTS";
+    readonly VOICE: "VOICE";
+    readonly VECTOR: "VECTOR";
+    readonly BUNDLER: "BUNDLER";
+    readonly DEPLOYER: "DEPLOYER";
+    readonly MEMORY: "MEMORY";
+    readonly STORAGE: "STORAGE";
+    readonly EMBEDDINGS: "EMBEDDINGS";
+};
+type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
+declare const LogLevel: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+    readonly NONE: "silent";
+};
+type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+interface BaseLogMessage extends Run {
+    msg: string;
+    level: number;
+    time: Date;
+    pid: number;
+    hostname: string;
+    name: string;
+}
+declare class LoggerTransport extends Transform {
+    constructor(opts?: any);
+    getLogsByRunId(_args: {
+        runId: string;
+    }): Promise<BaseLogMessage[]>;
+    getLogs(): Promise<BaseLogMessage[]>;
+}
+type TransportMap = Record<string, LoggerTransport>;
+declare class Logger {
+    protected logger: pino.Logger;
+    transports: TransportMap;
+    constructor(options?: {
+        name?: string;
+        level?: LogLevel;
+        transports?: TransportMap;
+        overrideDefaultTransports?: boolean;
+    });
+    debug(message: string, args?: Record<string, any>): void;
+    info(message: string, args?: Record<string, any>): void;
+    warn(message: string, args?: Record<string, any>): void;
+    error(message: string, args?: Record<string, any>): void;
+    createStream(): Transform;
+    getLogs(transportId: string): Promise<BaseLogMessage[]>;
+    getLogsByRunId({ runId, transportId }: {
+        transportId: string;
+        runId: string;
+    }): Promise<BaseLogMessage[] | undefined>;
+}
+declare function createLogger(options: {
+    name?: string;
+    level?: LogLevel;
+    transports?: TransportMap;
+}): Logger;
+declare class MultiLogger {
+    private loggers;
+    constructor(loggers: Logger[]);
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+declare function combineLoggers(loggers: Logger[]): MultiLogger;
+declare const noopLogger: {
+    debug: () => void;
+    info: () => void;
+    warn: () => void;
+    error: () => void;
+    cleanup: () => Promise<void>;
+};
+
+export { type BaseLogMessage as B, Logger as L, MultiLogger as M, RegisteredLogger as R, type TransportMap as T, LogLevel as a, LoggerTransport as b, combineLoggers as c, type Run as d, createLogger as e, noopLogger as n };