@mastra/core 0.0.0-commonjs-20250227130920

package/dist/utils.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function jsonSchemaPropertiesToTSTypes(value) {
+  if (!value.type) {
+    return zod.z.object({});
+  }
+  let zodType;
+  switch (value.type) {
+    case "string":
+      zodType = zod.z.string().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "number":
+      zodType = zod.z.number().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "integer":
+      zodType = zod.z.number().int().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "boolean":
+      zodType = zod.z.boolean().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "array":
+      zodType = zod.z.array(jsonSchemaPropertiesToTSTypes(value.items)).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "object":
+      zodType = jsonSchemaToModel(value).describe(
+        (value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : "")
+      );
+      break;
+    case "null":
+      zodType = zod.z.null().describe(value.description || "");
+      break;
+    default:
+      throw new Error(`Unsupported JSON schema type: ${value.type}`);
+  }
+  return zodType;
+}
+function jsonSchemaToModel(jsonSchema) {
+  const properties = jsonSchema.properties;
+  const requiredFields = jsonSchema.required || [];
+  if (!properties) {
+    return zod.z.object({});
+  }
+  const zodSchema = {};
+  for (const [key, _] of Object.entries(properties)) {
+    const value = _;
+    let zodType;
+    if (value.anyOf) {
+      const anyOfTypes = value.anyOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
+      zodType = zod.z.union(anyOfTypes).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+    } else if (value.allOf) {
+      const allOfTypes = value.allOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
+      zodType = zod.z.intersection(
+        allOfTypes[0],
+        allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])
+      ).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+    } else {
+      if (!value.type) {
+        value.type = "string";
+      }
+      zodType = jsonSchemaPropertiesToTSTypes(value);
+    }
+    if (value.description) {
+      zodType = zodType.describe(value.description);
+    }
+    if (requiredFields.includes(key)) {
+      zodSchema[key] = zodType;
+    } else {
+      zodSchema[key] = zodType.nullable();
+    }
+  }
+  return zod.z.object(zodSchema);
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (!source) return output;
+  Object.keys(source).forEach((key) => {
+    const targetValue = output[key];
+    const sourceValue = source[key];
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      output[key] = sourceValue;
+    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
+      output[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== void 0) {
+      output[key] = sourceValue;
+    }
+  });
+  return output;
+}
+async function* maskStreamTags(stream, tag, options = {}) {
+  const { onStart, onEnd, onMask } = options;
+  const openTag = `<${tag}>`;
+  const closeTag = `</${tag}>`;
+  let buffer = "";
+  let fullContent = "";
+  let isMasking = false;
+  let isBuffering = false;
+  const trimOutsideDelimiter = (text, delimiter, trim) => {
+    if (!text.includes(delimiter)) {
+      return text;
+    }
+    const parts = text.split(delimiter);
+    if (trim === `before-start`) {
+      return `${delimiter}${parts[1]}`;
+    }
+    return `${parts[0]}${delimiter}`;
+  };
+  const startsWith = (text, pattern) => {
+    if (pattern.includes(openTag.substring(0, 3))) {
+      pattern = trimOutsideDelimiter(pattern, `<`, `before-start`);
+    }
+    return text.trim().startsWith(pattern.trim());
+  };
+  for await (const chunk of stream) {
+    fullContent += chunk;
+    if (isBuffering) buffer += chunk;
+    const chunkHasTag = startsWith(chunk, openTag);
+    const bufferHasTag = !chunkHasTag && isBuffering && startsWith(openTag, buffer);
+    let toYieldBeforeMaskedStartTag = ``;
+    if (!isMasking && (chunkHasTag || bufferHasTag)) {
+      isMasking = true;
+      isBuffering = false;
+      const taggedTextToMask = trimOutsideDelimiter(buffer, `<`, `before-start`);
+      if (taggedTextToMask !== buffer.trim()) {
+        toYieldBeforeMaskedStartTag = buffer.replace(taggedTextToMask, ``);
+      }
+      buffer = "";
+      onStart?.();
+    }
+    if (!isMasking && !isBuffering && startsWith(openTag, chunk) && chunk.trim() !== "") {
+      isBuffering = true;
+      buffer += chunk;
+      continue;
+    }
+    if (isBuffering && buffer && !startsWith(openTag, buffer)) {
+      yield buffer;
+      buffer = "";
+      isBuffering = false;
+      continue;
+    }
+    if (isMasking && fullContent.includes(closeTag)) {
+      onMask?.(chunk);
+      onEnd?.();
+      isMasking = false;
+      const lastFullContent = fullContent;
+      fullContent = ``;
+      const textUntilEndTag = trimOutsideDelimiter(lastFullContent, closeTag, "after-end");
+      if (textUntilEndTag !== lastFullContent) {
+        yield lastFullContent.replace(textUntilEndTag, ``);
+      }
+      continue;
+    }
+    if (isMasking) {
+      onMask?.(chunk);
+      if (toYieldBeforeMaskedStartTag) {
+        yield toYieldBeforeMaskedStartTag;
+      }
+      continue;
+    }
+    yield chunk;
+  }
+}
+
+exports.deepMerge = deepMerge;
+exports.delay = delay;
+exports.jsonSchemaPropertiesToTSTypes = jsonSchemaPropertiesToTSTypes;
+exports.jsonSchemaToModel = jsonSchemaToModel;
+exports.maskStreamTags = maskStreamTags;

package/dist/utils.d.cts

@@ -0,0 +1,26 @@
+import { z, ZodObject } from 'zod';
+
+declare const delay: (ms: number) => Promise<unknown>;
+declare function jsonSchemaPropertiesToTSTypes(value: any): z.ZodTypeAny;
+declare function jsonSchemaToModel(jsonSchema: Record<string, any>): ZodObject<any>;
+/**
+ * Deep merges two objects, recursively merging nested objects and arrays
+ */
+declare function deepMerge<T extends object = object>(target: T, source: Partial<T>): T;
+interface TagMaskOptions {
+    /** Called when masking begins */
+    onStart?: () => void;
+    /** Called when masking ends */
+    onEnd?: () => void;
+    /** Called for each chunk that is masked */
+    onMask?: (chunk: string) => void;
+}
+/**
+ * Transforms a stream by masking content between XML tags.
+ * @param stream Input stream to transform
+ * @param tag Tag name to mask between (e.g. for <foo>...</foo>, use 'foo')
+ * @param options Optional configuration for masking behavior
+ */
+declare function maskStreamTags(stream: AsyncIterable<string>, tag: string, options?: TagMaskOptions): AsyncIterable<string>;
+
+export { type TagMaskOptions, deepMerge, delay, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, maskStreamTags };

package/dist/utils.d.ts

@@ -0,0 +1,26 @@
+import { z, ZodObject } from 'zod';
+
+declare const delay: (ms: number) => Promise<unknown>;
+declare function jsonSchemaPropertiesToTSTypes(value: any): z.ZodTypeAny;
+declare function jsonSchemaToModel(jsonSchema: Record<string, any>): ZodObject<any>;
+/**
+ * Deep merges two objects, recursively merging nested objects and arrays
+ */
+declare function deepMerge<T extends object = object>(target: T, source: Partial<T>): T;
+interface TagMaskOptions {
+    /** Called when masking begins */
+    onStart?: () => void;
+    /** Called when masking ends */
+    onEnd?: () => void;
+    /** Called for each chunk that is masked */
+    onMask?: (chunk: string) => void;
+}
+/**
+ * Transforms a stream by masking content between XML tags.
+ * @param stream Input stream to transform
+ * @param tag Tag name to mask between (e.g. for <foo>...</foo>, use 'foo')
+ * @param options Optional configuration for masking behavior
+ */
+declare function maskStreamTags(stream: AsyncIterable<string>, tag: string, options?: TagMaskOptions): AsyncIterable<string>;
+
+export { type TagMaskOptions, deepMerge, delay, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, maskStreamTags };

package/dist/utils.js

@@ -0,0 +1 @@
+export { deepMerge, delay, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, maskStreamTags } from './chunk-WIBGG4X6.js';

package/dist/vector/index.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+var stream = require('stream');
+var pino = require('pino');
+var pretty = require('pino-pretty');
+
+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
+      },
+      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/index.ts
+var MastraVector = class extends MastraBase {
+  constructor() {
+    super({ name: "MastraVector", component: "VECTOR" });
+  }
+};
+
+exports.MastraVector = MastraVector;

package/dist/vector/index.d.cts

@@ -0,0 +1,30 @@
+import { M as MastraBase } from '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface QueryResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+    vector?: number[];
+    document?: string;
+}
+interface IndexStats {
+    dimension: number;
+    count: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+declare abstract class MastraVector extends MastraBase {
+    constructor();
+    abstract upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    abstract createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    abstract query(indexName: string, queryVector: number[], topK?: number, filter?: Record<string, any>, includeVector?: boolean): Promise<QueryResult[]>;
+    abstract listIndexes(): Promise<string[]>;
+    abstract describeIndex(indexName: string): Promise<IndexStats>;
+    abstract deleteIndex(indexName: string): Promise<void>;
+}
+
+export { type IndexStats, MastraVector, type QueryResult };

package/dist/vector/index.d.ts

@@ -0,0 +1,30 @@
+import { M as MastraBase } from '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface QueryResult {
+    id: string;
+    score: number;
+    metadata?: Record<string, any>;
+    vector?: number[];
+    document?: string;
+}
+interface IndexStats {
+    dimension: number;
+    count: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+declare abstract class MastraVector extends MastraBase {
+    constructor();
+    abstract upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    abstract createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    abstract query(indexName: string, queryVector: number[], topK?: number, filter?: Record<string, any>, includeVector?: boolean): Promise<QueryResult[]>;
+    abstract listIndexes(): Promise<string[]>;
+    abstract describeIndex(indexName: string): Promise<IndexStats>;
+    abstract deleteIndex(indexName: string): Promise<void>;
+}
+
+export { type IndexStats, MastraVector, type QueryResult };

package/dist/vector/index.js

@@ -0,0 +1 @@
+export { MastraVector } from '../chunk-55NFNRKO.js';