@mastra/core 0.0.0-commonjs-20250227130920

package/dist/relevance/index.d.cts

@@ -0,0 +1,21 @@
+import { LanguageModelV1 } from 'ai';
+
+interface RelevanceScoreProvider {
+    getRelevanceScore(text1: string, text2: string): Promise<number>;
+}
+declare function createSimilarityPrompt(query: string, text: string): string;
+
+declare class CohereRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+
+declare class MastraAgentRelevanceScorer implements RelevanceScoreProvider {
+    private agent;
+    constructor(name: string, model: LanguageModelV1);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+
+export { CohereRelevanceScorer, MastraAgentRelevanceScorer, type RelevanceScoreProvider, createSimilarityPrompt };

package/dist/relevance/index.d.ts

@@ -0,0 +1,21 @@
+import { LanguageModelV1 } from 'ai';
+
+interface RelevanceScoreProvider {
+    getRelevanceScore(text1: string, text2: string): Promise<number>;
+}
+declare function createSimilarityPrompt(query: string, text: string): string;
+
+declare class CohereRelevanceScorer implements RelevanceScoreProvider {
+    private client;
+    private model;
+    constructor(model: string, apiKey?: string);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+
+declare class MastraAgentRelevanceScorer implements RelevanceScoreProvider {
+    private agent;
+    constructor(name: string, model: LanguageModelV1);
+    getRelevanceScore(query: string, text: string): Promise<number>;
+}
+
+export { CohereRelevanceScorer, MastraAgentRelevanceScorer, type RelevanceScoreProvider, createSimilarityPrompt };

package/dist/relevance/index.js

@@ -0,0 +1 @@
+export { CohereRelevanceScorer, MastraAgentRelevanceScorer, createSimilarityPrompt } from '../chunk-LH47WVJL.js';

package/dist/storage/index.cjs

@@ -0,0 +1,361 @@
+'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/storage/constants.ts
+var TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
+var TABLE_EVALS = "mastra_evals";
+var TABLE_MESSAGES = "mastra_messages";
+var TABLE_THREADS = "mastra_threads";
+var TABLE_TRACES = "mastra_traces";
+
+// src/storage/base.ts
+var MastraStorage = class extends MastraBase {
+  /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
+  static TABLE_WORKFLOW_SNAPSHOT = TABLE_WORKFLOW_SNAPSHOT;
+  /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
+  static TABLE_EVALS = TABLE_EVALS;
+  /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
+  static TABLE_MESSAGES = TABLE_MESSAGES;
+  /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
+  static TABLE_THREADS = TABLE_THREADS;
+  /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
+  static TABLE_TRACES = TABLE_TRACES;
+  hasInitialized = null;
+  constructor({ name }) {
+    super({
+      component: "STORAGE",
+      name
+    });
+  }
+  async __batchInsert({
+    tableName,
+    records
+  }) {
+    await this.init();
+    return this.batchInsert({ tableName, records });
+  }
+  async __getThreadById({ threadId }) {
+    await this.init();
+    return this.getThreadById({ threadId });
+  }
+  async __getThreadsByResourceId({ resourceId }) {
+    await this.init();
+    return this.getThreadsByResourceId({ resourceId });
+  }
+  async __saveThread({ thread }) {
+    await this.init();
+    return this.saveThread({ thread });
+  }
+  async __updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    await this.init();
+    return this.updateThread({ id, title, metadata });
+  }
+  async __deleteThread({ threadId }) {
+    await this.init();
+    return this.deleteThread({ threadId });
+  }
+  async __getMessages({ threadId, selectBy, threadConfig }) {
+    await this.init();
+    return this.getMessages({ threadId, selectBy, threadConfig });
+  }
+  async __saveMessages({ messages }) {
+    await this.init();
+    return this.saveMessages({ messages });
+  }
+  async __getTraces({
+    scope,
+    page,
+    perPage,
+    attributes
+  }) {
+    await this.init();
+    return this.getTraces({ scope, page, perPage, attributes });
+  }
+  async init() {
+    if (await this.hasInitialized) {
+      return;
+    }
+    this.hasInitialized = Promise.all([
+      this.createTable({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        schema: {
+          workflow_name: {
+            type: "text"
+          },
+          run_id: {
+            type: "text"
+          },
+          snapshot: {
+            type: "text"
+          },
+          createdAt: {
+            type: "timestamp"
+          },
+          updatedAt: {
+            type: "timestamp"
+          }
+        }
+      }),
+      this.createTable({
+        tableName: TABLE_EVALS,
+        schema: {
+          input: {
+            type: "text"
+          },
+          output: {
+            type: "text"
+          },
+          result: {
+            type: "jsonb"
+          },
+          agent_name: {
+            type: "text"
+          },
+          metric_name: {
+            type: "text"
+          },
+          instructions: {
+            type: "text"
+          },
+          test_info: {
+            type: "jsonb",
+            nullable: true
+          },
+          global_run_id: {
+            type: "text"
+          },
+          run_id: {
+            type: "text"
+          },
+          created_at: {
+            type: "timestamp"
+          }
+        }
+      }),
+      this.createTable({
+        tableName: TABLE_THREADS,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          resourceId: { type: "text", nullable: false },
+          title: { type: "text", nullable: false },
+          metadata: { type: "text", nullable: true },
+          createdAt: { type: "timestamp", nullable: false },
+          updatedAt: { type: "timestamp", nullable: false }
+        }
+      }),
+      this.createTable({
+        tableName: TABLE_MESSAGES,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          thread_id: { type: "text", nullable: false },
+          content: { type: "text", nullable: false },
+          role: { type: "text", nullable: false },
+          type: { type: "text", nullable: false },
+          createdAt: { type: "timestamp", nullable: false }
+        }
+      }),
+      this.createTable({
+        tableName: TABLE_TRACES,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          parentSpanId: { type: "text", nullable: true },
+          name: { type: "text", nullable: false },
+          traceId: { type: "text", nullable: false },
+          scope: { type: "text", nullable: false },
+          kind: { type: "integer", nullable: false },
+          attributes: { type: "jsonb", nullable: true },
+          status: { type: "jsonb", nullable: true },
+          events: { type: "jsonb", nullable: true },
+          links: { type: "jsonb", nullable: true },
+          other: { type: "text", nullable: true },
+          startTime: { type: "bigint", nullable: false },
+          endTime: { type: "bigint", nullable: false },
+          createdAt: { type: "timestamp", nullable: false }
+        }
+      })
+    ]).then(() => true);
+    await this.hasInitialized;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    await this.init();
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.insert({
+      tableName: 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: TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+  async __getEvalsByAgentName(agentName, type) {
+    await this.init();
+    return this.getEvalsByAgentName(agentName, type);
+  }
+};
+
+exports.MastraStorage = MastraStorage;
+exports.TABLE_EVALS = TABLE_EVALS;
+exports.TABLE_MESSAGES = TABLE_MESSAGES;
+exports.TABLE_THREADS = TABLE_THREADS;
+exports.TABLE_TRACES = TABLE_TRACES;
+exports.TABLE_WORKFLOW_SNAPSHOT = TABLE_WORKFLOW_SNAPSHOT;

package/dist/storage/index.d.cts

@@ -0,0 +1,15 @@
+export { E as EvalRow, M as MastraStorage, S as StorageColumn, d as StorageGetMessagesArg, aj as TABLE_EVALS, ak as TABLE_MESSAGES, T as TABLE_NAMES, al as TABLE_THREADS, am as TABLE_TRACES, ai as TABLE_WORKFLOW_SNAPSHOT, p as WorkflowRow } from '../base-nhesrHv3.cjs';
+import 'ai';
+import '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import '../types-m9RryK9a.cjs';
+import '../vector/index.cjs';
+import '../voice/index.cjs';
+import '../tts/index.cjs';

package/dist/storage/index.d.ts

@@ -0,0 +1,15 @@
+export { E as EvalRow, M as MastraStorage, S as StorageColumn, d as StorageGetMessagesArg, aj as TABLE_EVALS, ak as TABLE_MESSAGES, T as TABLE_NAMES, al as TABLE_THREADS, am as TABLE_TRACES, ai as TABLE_WORKFLOW_SNAPSHOT, p as WorkflowRow } from '../base-nKCMCNrM.js';
+import 'ai';
+import '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import '../types-m9RryK9a.js';
+import '../vector/index.js';
+import '../voice/index.js';
+import '../tts/index.js';

package/dist/storage/index.js

@@ -0,0 +1,2 @@
+export { MastraStorage } from '../chunk-5XPCMNGW.js';
+export { TABLE_EVALS, TABLE_MESSAGES, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT } from '../chunk-RG66XEJT.js';