@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/utils.d.cts

@@ -1,9 +1,9 @@
 import { MastraTTS } from './tts/index.cjs';
 import { MastraVector } from './vector/index.cjs';
-import { V as VercelTool, T as ToolAction, M as Mastra, a as MastraPrimitives, b as MastraMemory, C as CoreTool, A as Agent, W as Workflow } from './base-CTdONy0_.cjs';
+import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow, S as Step, d as StepExecutionContext, e as WorkflowContext } from './base-CIPKleAU.cjs';
+import { M as Metric } from './types-CwTG2XyQ.cjs';
 import { z, ZodObject } from 'zod';
 import { L as Logger } from './index-mKY1XrpK.cjs';
-import { M as Metric } from './types-CwTG2XyQ.cjs';
 import './base-DboIg_Cd.cjs';
 import './vector/filter/index.cjs';
 import 'ai';
@@ -65,6 +65,12 @@ interface ToolOptions {
     agentName?: string;
 }
 type ToolToConvert = VercelTool | ToolAction<any, any, any, any>;
+/**
+ * Ensures a tool has an ID and inputSchema by generating one if not present
+ * @param tool - The tool to ensure has an ID and inputSchema
+ * @returns The tool with an ID and inputSchema
+ */
+declare function ensureToolProperties(tools: ToolsInput): ToolsInput;
 /**
  * Converts a Vercel Tool or Mastra Tool into a CoreTool format
  * @param tool - The tool to convert (either VercelTool or ToolAction)
@@ -82,6 +88,6 @@ declare function makeCoreTool(tool: ToolToConvert, options: ToolOptions, logType
 declare function createMastraProxy({ mastra, logger }: {
     mastra: Mastra;
     logger: Logger;
-}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<any, any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
+}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<Step<string, any, any, StepExecutionContext<any, WorkflowContext<any, Step<string, any, any, any>[]>>>[], any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
 
-export { type TagMaskOptions, createMastraProxy, deepMerge, delay, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };
+export { type TagMaskOptions, createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };

package/dist/utils.d.ts

@@ -1,9 +1,9 @@
 import { MastraTTS } from './tts/index.js';
 import { MastraVector } from './vector/index.js';
-import { V as VercelTool, T as ToolAction, M as Mastra, a as MastraPrimitives, b as MastraMemory, C as CoreTool, A as Agent, W as Workflow } from './base-DIn_km7X.js';
+import { V as VercelTool, T as ToolAction, a as ToolsInput, M as Mastra, b as MastraPrimitives, c as MastraMemory, C as CoreTool, A as Agent, W as Workflow, S as Step, d as StepExecutionContext, e as WorkflowContext } from './base-C_Oq53qk.js';
+import { M as Metric } from './types-CwTG2XyQ.js';
 import { z, ZodObject } from 'zod';
 import { L as Logger } from './index-mKY1XrpK.js';
-import { M as Metric } from './types-CwTG2XyQ.js';
 import './base-BZViaFTt.js';
 import './vector/filter/index.js';
 import 'ai';
@@ -65,6 +65,12 @@ interface ToolOptions {
     agentName?: string;
 }
 type ToolToConvert = VercelTool | ToolAction<any, any, any, any>;
+/**
+ * Ensures a tool has an ID and inputSchema by generating one if not present
+ * @param tool - The tool to ensure has an ID and inputSchema
+ * @returns The tool with an ID and inputSchema
+ */
+declare function ensureToolProperties(tools: ToolsInput): ToolsInput;
 /**
  * Converts a Vercel Tool or Mastra Tool into a CoreTool format
  * @param tool - The tool to convert (either VercelTool or ToolAction)
@@ -82,6 +88,6 @@ declare function makeCoreTool(tool: ToolToConvert, options: ToolOptions, logType
 declare function createMastraProxy({ mastra, logger }: {
     mastra: Mastra;
     logger: Logger;
-}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<any, any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
+}): Mastra<Record<string, Agent<any, Record<string, Metric>>>, Record<string, Workflow<Step<string, any, any, StepExecutionContext<any, WorkflowContext<any, Step<string, any, any, any>[]>>>[], any>>, Record<string, MastraVector>, Record<string, MastraTTS>, Logger>;
 
-export { type TagMaskOptions, createMastraProxy, deepMerge, delay, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };
+export { type TagMaskOptions, createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };

package/dist/utils.js

@@ -1 +1 @@
-export { createMastraProxy, deepMerge, delay, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput } from './chunk-HBHPTMAC.js';
+export { createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput } from './chunk-4Y74D74B.js';

package/dist/vector/filter/index.cjs

@@ -1,192 +1,10 @@
 'use strict';
 
-// src/vector/filter/base.ts
-var BaseFilterTranslator = class _BaseFilterTranslator {
-  /**
-   * Operator type checks
-   */
-  isOperator(key) {
-    return key.startsWith("$");
-  }
-  static BASIC_OPERATORS = ["$eq", "$ne"];
-  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
-  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
-  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
-  static ELEMENT_OPERATORS = ["$exists"];
-  static REGEX_OPERATORS = ["$regex", "$options"];
-  static DEFAULT_OPERATORS = {
-    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
-    basic: _BaseFilterTranslator.BASIC_OPERATORS,
-    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
-    array: _BaseFilterTranslator.ARRAY_OPERATORS,
-    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
-    regex: _BaseFilterTranslator.REGEX_OPERATORS
-  };
-  isLogicalOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
-  }
-  isBasicOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
-  }
-  isNumericOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
-  }
-  isArrayOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
-  }
-  isElementOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
-  }
-  isRegexOperator(key) {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
-  }
-  isFieldOperator(key) {
-    return this.isOperator(key) && !this.isLogicalOperator(key);
-  }
-  isCustomOperator(key) {
-    const support = this.getSupportedOperators();
-    return support.custom?.includes(key) ?? false;
-  }
-  getSupportedOperators() {
-    return _BaseFilterTranslator.DEFAULT_OPERATORS;
-  }
-  isValidOperator(key) {
-    const support = this.getSupportedOperators();
-    const allSupported = Object.values(support).flat();
-    return allSupported.includes(key);
-  }
-  /**
-   * Value normalization for comparison operators
-   */
-  normalizeComparisonValue(value) {
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof value === "number" && Object.is(value, -0)) {
-      return 0;
-    }
-    return value;
-  }
-  /**
-   * Helper method to simulate $all operator using $and + $eq when needed.
-   * Some vector stores don't support $all natively.
-   */
-  simulateAllOperator(field, values) {
-    return {
-      $and: values.map((value) => ({
-        [field]: { $in: [this.normalizeComparisonValue(value)] }
-      }))
-    };
-  }
-  /**
-   * Utility functions for type checking
-   */
-  isPrimitive(value) {
-    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-  }
-  isRegex(value) {
-    return value instanceof RegExp;
-  }
-  isEmpty(obj) {
-    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
-  }
-  static ErrorMessages = {
-    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
-    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
-    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
-    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
-    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
-    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
-    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
-  };
-  /**
-   * Helper to handle array value normalization consistently
-   */
-  normalizeArrayValues(values) {
-    return values.map((value) => this.normalizeComparisonValue(value));
-  }
-  validateFilter(filter) {
-    const validation = this.validateFilterSupport(filter);
-    if (!validation.supported) {
-      throw new Error(validation.messages.join(", "));
-    }
-  }
-  /**
-   * Validates if a filter structure is supported by the specific vector DB
-   * and returns detailed validation information.
-   */
-  validateFilterSupport(node, path = "") {
-    const messages = [];
-    if (this.isPrimitive(node) || this.isEmpty(node)) {
-      return { supported: true, messages: [] };
-    }
-    if (Array.isArray(node)) {
-      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
-      const arrayMessages = arrayResults.flatMap((r) => r.messages);
-      return {
-        supported: arrayResults.every((r) => r.supported),
-        messages: arrayMessages
-      };
-    }
-    const nodeObj = node;
-    let isSupported = true;
-    for (const [key, value] of Object.entries(nodeObj)) {
-      const newPath = path ? `${path}.${key}` : key;
-      if (this.isOperator(key)) {
-        if (!this.isValidOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
-          continue;
-        }
-        if (!path && !this.isLogicalOperator(key)) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
-          continue;
-        }
-        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
-          isSupported = false;
-          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
-          continue;
-        }
-        if (this.isLogicalOperator(key)) {
-          if (key === "$not") {
-            if (Array.isArray(value) || typeof value !== "object") {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
-              continue;
-            }
-            if (this.isEmpty(value)) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
-              continue;
-            }
-            continue;
-          }
-          if (path && !this.isLogicalOperator(path.split(".").pop())) {
-            isSupported = false;
-            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
-            continue;
-          }
-          if (Array.isArray(value)) {
-            const hasDirectOperators = value.some(
-              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
-            );
-            if (hasDirectOperators) {
-              isSupported = false;
-              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
-              continue;
-            }
-          }
-        }
-      }
-      const nestedValidation = this.validateFilterSupport(value, newPath);
-      if (!nestedValidation.supported) {
-        isSupported = false;
-        messages.push(...nestedValidation.messages);
-      }
-    }
-    return { supported: isSupported, messages };
-  }
-};
+var chunkYK3XJ52U_cjs = require('../../chunk-YK3XJ52U.cjs');
 
-exports.BaseFilterTranslator = BaseFilterTranslator;
+
+
+Object.defineProperty(exports, "BaseFilterTranslator", {
+  enumerable: true,
+  get: function () { return chunkYK3XJ52U_cjs.BaseFilterTranslator; }
+});

package/dist/vector/index.cjs

@@ -1,177 +1,10 @@
 'use strict';
 
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
+var chunkENT7U27Y_cjs = require('../chunk-ENT7U27Y.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
 
-// src/logger/index.ts
-var RegisteredLogger = {
-  LLM: "LLM"};
-var LogLevel = {
-  INFO: "info"};
-var Logger = class {
-  logger;
-  transports;
-  constructor(options = {}) {
-    this.transports = options.transports || {};
-    const transportsAry = Object.entries(this.transports);
-    this.logger = pino__default.default(
-      {
-        name: options.name || "app",
-        level: options.level || LogLevel.INFO,
-        formatters: {
-          level: (label) => {
-            return {
-              level: label
-            };
-          }
-        }
-      },
-      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
-        colorize: true,
-        levelFirst: true,
-        ignore: "pid,hostname",
-        colorizeObjects: true,
-        translateTime: "SYS:standard",
-        singleLine: false
-      }) : pino__default.default.multistream([
-        ...transportsAry.map(([_, transport]) => ({
-          stream: transport,
-          level: options.level || LogLevel.INFO
-        })),
-        {
-          stream: pretty__default.default({
-            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);
-  }
-  info(message, args = {}) {
-    this.logger.info(args, message);
-  }
-  warn(message, args = {}) {
-    this.logger.warn(args, message);
-  }
-  error(message, args = {}) {
-    this.logger.error(args, message);
-  }
-  // Stream creation for process output handling
-  createStream() {
-    return new stream.Transform({
-      transform: (chunk, _encoding, callback) => {
-        const line = chunk.toString().trim();
-        if (line) {
-          this.info(line);
-        }
-        callback(null, chunk);
-      }
-    });
-  }
-  async getLogs(transportId) {
-    if (!transportId || !this.transports[transportId]) {
-      return [];
-    }
-    return this.transports[transportId].getLogs();
-  }
-  async getLogsByRunId({ runId, transportId }) {
-    return this.transports[transportId]?.getLogsByRunId({ runId });
-  }
-};
-function createLogger(options) {
-  return new Logger(options);
-}
-
-// src/base.ts
-var MastraBase = class {
-  component = RegisteredLogger.LLM;
-  logger;
-  name;
-  telemetry;
-  constructor({ component, name }) {
-    this.component = component || RegisteredLogger.LLM;
-    this.name = name;
-    this.logger = createLogger({ name: `${this.component} - ${this.name}` });
-  }
-  /**
-   * Set the logger for the agent
-   * @param logger
-   */
-  __setLogger(logger) {
-    this.logger = logger;
-    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
-  }
-  /**
-   * Set the telemetry for the
-   * @param telemetry
-   */
-  __setTelemetry(telemetry) {
-    this.telemetry = telemetry;
-    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
-  }
-  /**
-   * Get the telemetry on the vector
-   * @returns telemetry
-   */
-  __getTelemetry() {
-    return this.telemetry;
-  }
-  /* 
-    get experimental_telemetry config
-    */
-  get experimental_telemetry() {
-    return this.telemetry ? {
-      // tracer: this.telemetry.tracer,
-      tracer: this.telemetry.getBaggageTracer(),
-      isEnabled: !!this.telemetry.tracer
-    } : void 0;
-  }
-};
-
-// src/vector/vector.ts
-var MastraVector = class extends MastraBase {
-  constructor() {
-    super({ name: "MastraVector", component: "VECTOR" });
-  }
-  baseKeys = {
-    query: ["queryVector", "topK", "filter", "includeVector"],
-    upsert: ["vectors", "metadata", "ids"],
-    createIndex: ["dimension", "metric"]
-  };
-  normalizeArgs(method, [first, ...rest], extendedKeys = []) {
-    if (typeof first === "object") {
-      return first;
-    }
-    this.logger.warn(
-      `Deprecation Warning: Passing individual arguments to ${method}() is deprecated. Please use an object parameter instead.`
-    );
-    const baseKeys = this.baseKeys[method] || [];
-    const paramKeys = [...baseKeys, ...extendedKeys].slice(0, rest.length);
-    return {
-      indexName: first,
-      ...Object.fromEntries(paramKeys.map((key, i) => [key, rest[i]]))
-    };
-  }
-  async updateIndexById(_indexName, _id, _update) {
-    throw new Error("updateIndexById is not implemented yet");
-  }
-  async deleteIndexById(_indexName, _id) {
-    throw new Error("deleteById is not implemented yet");
-  }
-};
-
-exports.MastraVector = MastraVector;
+Object.defineProperty(exports, "MastraVector", {
+  enumerable: true,
+  get: function () { return chunkENT7U27Y_cjs.MastraVector; }
+});