@mastra/core
Version:
The core foundation of the Mastra framework, providing essential components and interfaces for building AI-powered applications.
537 lines (532 loc) • 15.8 kB
JavaScript
'use strict';
var chunkLXFZUKP3_cjs = require('./chunk-LXFZUKP3.cjs');
var chunkL5FURQXC_cjs = require('./chunk-L5FURQXC.cjs');
var chunk2D7NOO7S_cjs = require('./chunk-2D7NOO7S.cjs');
var chunkZIZ3CVHN_cjs = require('./chunk-ZIZ3CVHN.cjs');
var chunkU64IJDC5_cjs = require('./chunk-U64IJDC5.cjs');
// src/mastra/index.ts
var _Mastra_decorators, _init;
_Mastra_decorators = [chunkL5FURQXC_cjs.InstrumentClass({
prefix: "mastra",
excludeMethods: ["getLogger", "getTelemetry"]
})];
exports.Mastra = class Mastra {
#vectors;
#agents;
#logger;
#legacy_workflows;
#workflows;
#tts;
#deployer;
#serverMiddleware = [];
#telemetry;
#storage;
#memory;
#networks;
#server;
#mcpServers;
#bundler;
/**
* @deprecated use getTelemetry() instead
*/
get telemetry() {
return this.#telemetry;
}
/**
* @deprecated use getStorage() instead
*/
get storage() {
return this.#storage;
}
/**
* @deprecated use getMemory() instead
*/
get memory() {
return this.#memory;
}
constructor(config) {
if (config?.serverMiddleware) {
this.#serverMiddleware = config.serverMiddleware.map(m => ({
handler: m.handler,
path: m.path || "/api/*"
}));
}
let logger;
if (config?.logger === false) {
logger = chunk2D7NOO7S_cjs.noopLogger;
} else {
if (config?.logger) {
logger = config.logger;
} else {
const levelOnEnv = process.env.NODE_ENV === "production" && process.env.MASTRA_DEV !== "true" ? chunkZIZ3CVHN_cjs.LogLevel.WARN : chunkZIZ3CVHN_cjs.LogLevel.INFO;
logger = new chunkZIZ3CVHN_cjs.ConsoleLogger({
name: "Mastra",
level: levelOnEnv
});
}
}
this.#logger = logger;
let storage = config?.storage;
if (storage) {
storage = chunkLXFZUKP3_cjs.augmentWithInit(storage);
}
this.#telemetry = chunkL5FURQXC_cjs.Telemetry.init(config?.telemetry);
if (this.#telemetry && storage) {
this.#storage = this.#telemetry.traceClass(storage, {
excludeMethods: ["__setTelemetry", "__getTelemetry", "batchTraceInsert", "getTraces", "getEvalsByAgentName"]
});
this.#storage.__setTelemetry(this.#telemetry);
} else {
this.#storage = storage;
}
if (config?.vectors) {
let vectors = {};
Object.entries(config.vectors).forEach(([key, vector]) => {
if (this.#telemetry) {
vectors[key] = this.#telemetry.traceClass(vector, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
vectors[key].__setTelemetry(this.#telemetry);
} else {
vectors[key] = vector;
}
});
this.#vectors = vectors;
}
if (config?.vectors) {
this.#vectors = config.vectors;
}
if (config?.networks) {
this.#networks = config.networks;
}
if (config?.mcpServers) {
this.#mcpServers = config.mcpServers;
Object.entries(this.#mcpServers).forEach(([key, server]) => {
server.setId(key);
if (this.#telemetry) {
server.__setTelemetry(this.#telemetry);
}
server.__registerMastra(this);
server.__setLogger(this.getLogger());
});
}
if (config && `memory` in config) {
throw new Error(`
Memory should be added to Agents, not to Mastra.
Instead of:
new Mastra({ memory: new Memory() })
do:
new Agent({ memory: new Memory() })
`);
}
if (config?.tts) {
this.#tts = config.tts;
Object.entries(this.#tts).forEach(([key, ttsCl]) => {
if (this.#tts?.[key]) {
if (this.#telemetry) {
this.#tts[key] = this.#telemetry.traceClass(ttsCl, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
this.#tts[key].__setTelemetry(this.#telemetry);
}
}
});
}
const agents = {};
if (config?.agents) {
Object.entries(config.agents).forEach(([key, agent]) => {
if (agents[key]) {
throw new Error(`Agent with name ID:${key} already exists`);
}
agent.__registerMastra(this);
agent.__registerPrimitives({
logger: this.getLogger(),
telemetry: this.#telemetry,
storage: this.storage,
memory: this.memory,
agents,
tts: this.#tts,
vectors: this.#vectors
});
agents[key] = agent;
});
}
this.#agents = agents;
this.#networks = {};
if (config?.networks) {
Object.entries(config.networks).forEach(([key, network]) => {
network.__registerMastra(this);
this.#networks[key] = network;
});
}
this.#legacy_workflows = {};
if (config?.legacy_workflows) {
Object.entries(config.legacy_workflows).forEach(([key, workflow]) => {
workflow.__registerMastra(this);
workflow.__registerPrimitives({
logger: this.getLogger(),
telemetry: this.#telemetry,
storage: this.storage,
memory: this.memory,
agents,
tts: this.#tts,
vectors: this.#vectors
});
this.#legacy_workflows[key] = workflow;
const workflowSteps = Object.values(workflow.steps).filter(step => !!step.workflowId && !!step.workflow);
if (workflowSteps.length > 0) {
workflowSteps.forEach(step => {
this.#legacy_workflows[step.workflowId] = step.workflow;
});
}
});
}
this.#workflows = {};
if (config?.workflows) {
Object.entries(config.workflows).forEach(([key, workflow]) => {
workflow.__registerMastra(this);
workflow.__registerPrimitives({
logger: this.getLogger(),
telemetry: this.#telemetry,
storage: this.storage,
memory: this.memory,
agents,
tts: this.#tts,
vectors: this.#vectors
});
this.#workflows[key] = workflow;
});
}
if (config?.server) {
this.#server = config.server;
}
this.setLogger({
logger
});
}
getAgent(name) {
const agent = this.#agents?.[name];
if (!agent) {
throw new Error(`Agent with name ${String(name)} not found`);
}
return this.#agents[name];
}
getAgents() {
return this.#agents;
}
getVector(name) {
const vector = this.#vectors?.[name];
if (!vector) {
throw new Error(`Vector with name ${String(name)} not found`);
}
return vector;
}
getVectors() {
return this.#vectors;
}
getDeployer() {
return this.#deployer;
}
legacy_getWorkflow(id, {
serialized
} = {}) {
const workflow = this.#legacy_workflows?.[id];
if (!workflow) {
throw new Error(`Workflow with ID ${String(id)} not found`);
}
if (serialized) {
return {
name: workflow.name
};
}
return workflow;
}
getWorkflow(id, {
serialized
} = {}) {
const workflow = this.#workflows?.[id];
if (!workflow) {
throw new Error(`Workflow with ID ${String(id)} not found`);
}
if (serialized) {
return {
name: workflow.name
};
}
return workflow;
}
legacy_getWorkflows(props = {}) {
if (props.serialized) {
return Object.entries(this.#legacy_workflows).reduce((acc, [k, v]) => {
return {
...acc,
[k]: {
name: v.name
}
};
}, {});
}
return this.#legacy_workflows;
}
getWorkflows(props = {}) {
if (props.serialized) {
return Object.entries(this.#workflows).reduce((acc, [k, v]) => {
return {
...acc,
[k]: {
name: v.name
}
};
}, {});
}
return this.#workflows;
}
setStorage(storage) {
this.#storage = chunkLXFZUKP3_cjs.augmentWithInit(storage);
}
setLogger({
logger
}) {
this.#logger = logger;
if (this.#agents) {
Object.keys(this.#agents).forEach(key => {
this.#agents?.[key]?.__setLogger(this.#logger);
});
}
if (this.#memory) {
this.#memory.__setLogger(this.#logger);
}
if (this.#deployer) {
this.#deployer.__setLogger(this.#logger);
}
if (this.#tts) {
Object.keys(this.#tts).forEach(key => {
this.#tts?.[key]?.__setLogger(this.#logger);
});
}
if (this.#storage) {
this.#storage.__setLogger(this.#logger);
}
if (this.#vectors) {
Object.keys(this.#vectors).forEach(key => {
this.#vectors?.[key]?.__setLogger(this.#logger);
});
}
if (this.#mcpServers) {
Object.keys(this.#mcpServers).forEach(key => {
this.#mcpServers?.[key]?.__setLogger(this.#logger);
});
}
}
setTelemetry(telemetry) {
this.#telemetry = chunkL5FURQXC_cjs.Telemetry.init(telemetry);
if (this.#agents) {
Object.keys(this.#agents).forEach(key => {
if (this.#telemetry) {
this.#agents?.[key]?.__setTelemetry(this.#telemetry);
}
});
}
if (this.#memory) {
this.#memory = this.#telemetry.traceClass(this.#memory, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
this.#memory.__setTelemetry(this.#telemetry);
}
if (this.#deployer) {
this.#deployer = this.#telemetry.traceClass(this.#deployer, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
this.#deployer.__setTelemetry(this.#telemetry);
}
if (this.#tts) {
let tts = {};
Object.entries(this.#tts).forEach(([key, ttsCl]) => {
if (this.#telemetry) {
tts[key] = this.#telemetry.traceClass(ttsCl, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
tts[key].__setTelemetry(this.#telemetry);
}
});
this.#tts = tts;
}
if (this.#storage) {
this.#storage = this.#telemetry.traceClass(this.#storage, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
this.#storage.__setTelemetry(this.#telemetry);
}
if (this.#vectors) {
let vectors = {};
Object.entries(this.#vectors).forEach(([key, vector]) => {
if (this.#telemetry) {
vectors[key] = this.#telemetry.traceClass(vector, {
excludeMethods: ["__setTelemetry", "__getTelemetry"]
});
vectors[key].__setTelemetry(this.#telemetry);
}
});
this.#vectors = vectors;
}
}
getTTS() {
return this.#tts;
}
getLogger() {
return this.#logger;
}
getTelemetry() {
return this.#telemetry;
}
getMemory() {
return this.#memory;
}
getStorage() {
return this.#storage;
}
getServerMiddleware() {
return this.#serverMiddleware;
}
setServerMiddleware(serverMiddleware) {
if (typeof serverMiddleware === "function") {
this.#serverMiddleware = [{
handler: serverMiddleware,
path: "/api/*"
}];
return;
}
if (!Array.isArray(serverMiddleware)) {
throw new Error(`Invalid middleware: expected a function or array, received ${typeof serverMiddleware}`);
}
this.#serverMiddleware = serverMiddleware.map(m => {
if (typeof m === "function") {
return {
handler: m,
path: "/api/*"
};
}
return {
handler: m.handler,
path: m.path || "/api/*"
};
});
}
getNetworks() {
return Object.values(this.#networks || {});
}
getServer() {
return this.#server;
}
getBundlerConfig() {
return this.#bundler;
}
/**
* Get a specific network by ID
* @param networkId - The ID of the network to retrieve
* @returns The network with the specified ID, or undefined if not found
*/
getNetwork(networkId) {
const networks = this.getNetworks();
return networks.find(network => {
const routingAgent = network.getRoutingAgent();
return network.formatAgentId(routingAgent.name) === networkId;
});
}
async getLogsByRunId({
runId,
transportId,
fromDate,
toDate,
logLevel,
filters,
page,
perPage
}) {
if (!transportId) {
throw new Error("Transport ID is required");
}
if (!this.#logger?.getLogsByRunId) {
throw new Error("Logger is not set");
}
return await this.#logger.getLogsByRunId({
runId,
transportId,
fromDate,
toDate,
logLevel,
filters,
page,
perPage
});
}
async getLogs(transportId, params) {
if (!transportId) {
throw new Error("Transport ID is required");
}
if (!this.#logger?.getLogs) {
throw new Error("Logger is not set");
}
return await this.#logger.getLogs(transportId, params);
}
/**
* Get all registered MCP server instances.
* @returns A record of MCP server ID to MCPServerBase instance, or undefined if none are registered.
*/
getMCPServers() {
return this.#mcpServers;
}
/**
* Get a specific MCP server instance.
* If a version is provided, it attempts to find the server with that exact logical ID and version.
* If no version is provided, it returns the server with the specified logical ID that has the most recent releaseDate.
* The logical ID should match the `id` property of the MCPServer instance (typically set via MCPServerConfig.id).
* @param serverId - The logical ID of the MCP server to retrieve.
* @param version - Optional specific version of the MCP server to retrieve.
* @returns The MCP server instance, or undefined if not found or if the specific version is not found.
*/
getMCPServer(serverId, version) {
if (!this.#mcpServers) {
return void 0;
}
const allRegisteredServers = Object.values(this.#mcpServers || {});
const matchingLogicalIdServers = allRegisteredServers.filter(server => server.id === serverId);
if (matchingLogicalIdServers.length === 0) {
this.#logger?.debug(`No MCP servers found with logical ID: ${serverId}`);
return void 0;
}
if (version) {
const specificVersionServer = matchingLogicalIdServers.find(server => server.version === version);
if (!specificVersionServer) {
this.#logger?.debug(`MCP server with logical ID '${serverId}' found, but not version '${version}'.`);
}
return specificVersionServer;
} else {
if (matchingLogicalIdServers.length === 1) {
return matchingLogicalIdServers[0];
}
matchingLogicalIdServers.sort((a, b) => {
const dateAVal = a.releaseDate && typeof a.releaseDate === "string" ? new Date(a.releaseDate).getTime() : NaN;
const dateBVal = b.releaseDate && typeof b.releaseDate === "string" ? new Date(b.releaseDate).getTime() : NaN;
if (isNaN(dateAVal) && isNaN(dateBVal)) return 0;
if (isNaN(dateAVal)) return 1;
if (isNaN(dateBVal)) return -1;
return dateBVal - dateAVal;
});
if (matchingLogicalIdServers.length > 0) {
const latestServer = matchingLogicalIdServers[0];
if (latestServer && latestServer.releaseDate && typeof latestServer.releaseDate === "string" && !isNaN(new Date(latestServer.releaseDate).getTime())) {
return latestServer;
}
}
this.#logger?.warn(`Could not determine the latest server for logical ID '${serverId}' due to invalid or missing release dates, or no servers left after filtering.`);
return void 0;
}
}
};
exports.Mastra = /*@__PURE__*/(_ => {
_init = chunkU64IJDC5_cjs.__decoratorStart(null);
exports.Mastra = chunkU64IJDC5_cjs.__decorateElement(_init, 0, "Mastra", _Mastra_decorators, exports.Mastra);
chunkU64IJDC5_cjs.__runInitializers(_init, 1, exports.Mastra);
return exports.Mastra;
})();