@mastra/core 1.0.0-beta.1 → 1.0.0-beta.11

package/dist/{chunk-MV7KHWUT.js → chunk-JIGDJK2O.js}

@@ -1,6 +1,6 @@
-import { MessageList } from './chunk-JV2KH24V.js';
+import { MessageList } from './chunk-SXNQRJQD.js';
 import { MastraError } from './chunk-JJ5O45LH.js';
-import { MastraBase } from './chunk-S6URFGCZ.js';
+import { MastraBase } from './chunk-LSHPJWM5.js';
 
 // src/storage/constants.ts
 var TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
@@ -10,6 +10,7 @@ var TABLE_TRACES = "mastra_traces";
 var TABLE_RESOURCES = "mastra_resources";
 var TABLE_SCORERS = "mastra_scorers";
 var TABLE_SPANS = "mastra_ai_spans";
+var TABLE_AGENTS = "mastra_agents";
 var SCORERS_SCHEMA = {
   id: { type: "text", nullable: false, primaryKey: true },
   scorerId: { type: "text" },
@@ -77,6 +78,35 @@ var SPAN_SCHEMA = {
   // The time the database record was last updated
   isEvent: { type: "boolean", nullable: false }
 };
+var AGENTS_SCHEMA = {
+  id: { type: "text", nullable: false, primaryKey: true },
+  name: { type: "text", nullable: false },
+  description: { type: "text", nullable: true },
+  instructions: { type: "text", nullable: false },
+  // System instructions for the agent
+  model: { type: "jsonb", nullable: false },
+  // Model configuration (provider, name, etc.)
+  tools: { type: "jsonb", nullable: true },
+  // Serialized tool references/configurations
+  defaultOptions: { type: "jsonb", nullable: true },
+  // Default options for generate/stream calls
+  workflows: { type: "jsonb", nullable: true },
+  // Workflow references (IDs or configurations)
+  agents: { type: "jsonb", nullable: true },
+  // Sub-agent references (IDs or configurations)
+  inputProcessors: { type: "jsonb", nullable: true },
+  // Input processor configurations
+  outputProcessors: { type: "jsonb", nullable: true },
+  // Output processor configurations
+  memory: { type: "jsonb", nullable: true },
+  // Memory configuration
+  scorers: { type: "jsonb", nullable: true },
+  // Scorer configurations
+  metadata: { type: "jsonb", nullable: true },
+  // Additional metadata for the agent
+  createdAt: { type: "timestamp", nullable: false },
+  updatedAt: { type: "timestamp", nullable: false }
+};
 var TABLE_SCHEMAS = {
   [TABLE_WORKFLOW_SNAPSHOT]: {
     workflow_name: {
@@ -137,7 +167,8 @@ var TABLE_SCHEMAS = {
     metadata: { type: "jsonb", nullable: true },
     createdAt: { type: "timestamp", nullable: false },
     updatedAt: { type: "timestamp", nullable: false }
-  }
+  },
+  [TABLE_AGENTS]: AGENTS_SCHEMA
 };
 
 // src/storage/base.ts
@@ -171,7 +202,27 @@ var MastraStorage = class extends MastraBase {
   shouldCacheInit = true;
   id;
   stores;
-  constructor({ id, name }) {
+  /**
+   * When true, automatic initialization (table creation/migrations) is disabled.
+   * This is useful for CI/CD pipelines where you want to:
+   * 1. Run migrations explicitly during deployment (not at runtime)
+   * 2. Use different credentials for schema changes vs runtime operations
+   *
+   * When disableInit is true:
+   * - The storage will not automatically create/alter tables on first use
+   * - You must call `storage.init()` explicitly in your CI/CD scripts
+   *
+   * @example
+   * // In CI/CD script:
+   * const storage = new PostgresStore({ ...config, disableInit: false });
+   * await storage.init(); // Explicitly run migrations
+   *
+   * // In runtime application:
+   * const storage = new PostgresStore({ ...config, disableInit: true });
+   * // No auto-init, tables must already exist
+   */
+  disableInit = false;
+  constructor({ id, name, disableInit }) {
     if (!id || typeof id !== "string" || id.trim() === "") {
       throw new Error(`${name}: id must be provided and cannot be empty.`);
     }
@@ -180,6 +231,7 @@ var MastraStorage = class extends MastraBase {
       name
     });
     this.id = id;
+    this.disableInit = disableInit ?? false;
   }
   get supports() {
     return {
@@ -190,7 +242,8 @@ var MastraStorage = class extends MastraBase {
       deleteMessages: false,
       observabilityInstance: false,
       indexManagement: false,
-      listScoresBySpan: false
+      listScoresBySpan: false,
+      agents: false
     };
   }
   ensureDate(date) {
@@ -341,6 +394,14 @@ var MastraStorage = class extends MastraBase {
         })
       );
     }
+    if (this.supports.agents) {
+      tableCreationTasks.push(
+        this.createTable({
+          tableName: TABLE_AGENTS,
+          schema: TABLE_SCHEMAS[TABLE_AGENTS]
+        })
+      );
+    }
     this.hasInitialized = Promise.all(tableCreationTasks).then(() => true);
     await this.hasInitialized;
     await this?.alterTable?.({
@@ -587,6 +648,232 @@ var MastraStorage = class extends MastraBase {
       text: `Index management is not supported by this storage adapter (${this.constructor.name})`
     });
   }
+  /**
+   * AGENTS STORAGE
+   * These methods delegate to the agents store for agent CRUD operations.
+   * This enables dynamic creation of agents via Mastra Studio.
+   */
+  /**
+   * Retrieves an agent by its unique identifier.
+   * @param id - The unique identifier of the agent
+   * @returns The agent if found, null otherwise
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async getAgentById({ id }) {
+    if (this.stores?.agents) {
+      return this.stores.agents.getAgentById({ id });
+    }
+    throw new MastraError({
+      id: "MASTRA_STORAGE_GET_AGENT_BY_ID_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Creates a new agent in storage.
+   * @param agent - The agent data to create
+   * @returns The created agent with timestamps
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async createAgent({ agent }) {
+    if (this.stores?.agents) {
+      return this.stores.agents.createAgent({ agent });
+    }
+    throw new MastraError({
+      id: "MASTRA_STORAGE_CREATE_AGENT_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Updates an existing agent in storage.
+   * @param id - The unique identifier of the agent to update
+   * @param updates - The fields to update
+   * @returns The updated agent
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async updateAgent(args) {
+    if (this.stores?.agents) {
+      return this.stores.agents.updateAgent(args);
+    }
+    throw new MastraError({
+      id: "MASTRA_STORAGE_UPDATE_AGENT_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Deletes an agent from storage.
+   * @param id - The unique identifier of the agent to delete
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async deleteAgent({ id }) {
+    if (this.stores?.agents) {
+      return this.stores.agents.deleteAgent({ id });
+    }
+    throw new MastraError({
+      id: "MASTRA_STORAGE_DELETE_AGENT_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+  /**
+   * Lists all agents with optional pagination.
+   * @param args - Pagination and ordering options
+   * @returns Paginated list of agents
+   * @throws {MastraError} if not supported by the storage adapter
+   */
+  async listAgents(args) {
+    if (this.stores?.agents) {
+      return this.stores.agents.listAgents(args);
+    }
+    throw new MastraError({
+      id: "MASTRA_STORAGE_LIST_AGENTS_NOT_SUPPORTED",
+      domain: "STORAGE" /* STORAGE */,
+      category: "SYSTEM" /* SYSTEM */,
+      text: `Agent storage is not supported by this storage adapter (${this.constructor.name})`
+    });
+  }
+};
+
+// src/storage/domains/agents/base.ts
+var AgentsStorage = class extends MastraBase {
+  constructor() {
+    super({
+      component: "STORAGE",
+      name: "AGENTS"
+    });
+  }
+  /**
+   * Parses orderBy input for consistent sorting behavior.
+   */
+  parseOrderBy(orderBy, defaultDirection = "DESC") {
+    return {
+      field: orderBy?.field && orderBy.field in AGENT_ORDER_BY_SET ? orderBy.field : "createdAt",
+      direction: orderBy?.direction && orderBy.direction in AGENT_SORT_DIRECTION_SET ? orderBy.direction : defaultDirection
+    };
+  }
+};
+var AGENT_ORDER_BY_SET = {
+  createdAt: true,
+  updatedAt: true
+};
+var AGENT_SORT_DIRECTION_SET = {
+  ASC: true,
+  DESC: true
+};
+
+// src/storage/domains/agents/inmemory.ts
+var InMemoryAgentsStorage = class extends AgentsStorage {
+  collection;
+  constructor({ collection }) {
+    super();
+    this.collection = collection;
+  }
+  async getAgentById({ id }) {
+    this.logger.debug(`InMemoryAgentsStorage: getAgentById called for ${id}`);
+    const agent = this.collection.get(id);
+    return agent ? {
+      ...agent,
+      metadata: agent.metadata ? { ...agent.metadata } : agent.metadata,
+      model: { ...agent.model },
+      tools: agent.tools ? [...agent.tools] : agent.tools,
+      workflows: agent.workflows ? [...agent.workflows] : agent.workflows,
+      agents: agent.agents ? [...agent.agents] : agent.agents,
+      scorers: agent.scorers ? { ...agent.scorers } : agent.scorers
+    } : null;
+  }
+  async createAgent({ agent }) {
+    this.logger.debug(`InMemoryAgentsStorage: createAgent called for ${agent.id}`);
+    if (this.collection.has(agent.id)) {
+      throw new Error(`Agent with id ${agent.id} already exists`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const newAgent = {
+      ...agent,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.collection.set(agent.id, newAgent);
+    return { ...newAgent };
+  }
+  async updateAgent({ id, ...updates }) {
+    this.logger.debug(`InMemoryAgentsStorage: updateAgent called for ${id}`);
+    const existingAgent = this.collection.get(id);
+    if (!existingAgent) {
+      throw new Error(`Agent with id ${id} not found`);
+    }
+    const updatedAgent = {
+      ...existingAgent,
+      ...updates.name !== void 0 && { name: updates.name },
+      ...updates.description !== void 0 && { description: updates.description },
+      ...updates.instructions !== void 0 && { instructions: updates.instructions },
+      ...updates.model !== void 0 && { model: updates.model },
+      ...updates.tools !== void 0 && { tools: updates.tools },
+      ...updates.defaultOptions !== void 0 && {
+        defaultOptions: updates.defaultOptions
+      },
+      ...updates.workflows !== void 0 && { workflows: updates.workflows },
+      ...updates.agents !== void 0 && { agents: updates.agents },
+      ...updates.inputProcessors !== void 0 && { inputProcessors: updates.inputProcessors },
+      ...updates.outputProcessors !== void 0 && { outputProcessors: updates.outputProcessors },
+      ...updates.memory !== void 0 && { memory: updates.memory },
+      ...updates.scorers !== void 0 && { scorers: updates.scorers },
+      ...updates.metadata !== void 0 && {
+        metadata: { ...existingAgent.metadata, ...updates.metadata }
+      },
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.collection.set(id, updatedAgent);
+    return { ...updatedAgent };
+  }
+  async deleteAgent({ id }) {
+    this.logger.debug(`InMemoryAgentsStorage: deleteAgent called for ${id}`);
+    this.collection.delete(id);
+  }
+  async listAgents(args) {
+    const { page = 0, perPage: perPageInput, orderBy } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    this.logger.debug(`InMemoryAgentsStorage: listAgents called`);
+    const perPage = normalizePerPage(perPageInput, 100);
+    if (page < 0) {
+      throw new Error("page must be >= 0");
+    }
+    const maxOffset = Number.MAX_SAFE_INTEGER / 2;
+    if (page * perPage > maxOffset) {
+      throw new Error("page value too large");
+    }
+    const agents = Array.from(this.collection.values());
+    const sortedAgents = this.sortAgents(agents, field, direction);
+    const clonedAgents = sortedAgents.map((agent) => ({
+      ...agent,
+      metadata: agent.metadata ? { ...agent.metadata } : agent.metadata,
+      model: { ...agent.model },
+      tools: agent.tools ? [...agent.tools] : agent.tools,
+      workflows: agent.workflows ? [...agent.workflows] : agent.workflows,
+      agents: agent.agents ? [...agent.agents] : agent.agents,
+      scorers: agent.scorers ? { ...agent.scorers } : agent.scorers
+    }));
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    return {
+      agents: clonedAgents.slice(offset, offset + perPage),
+      total: clonedAgents.length,
+      page,
+      perPage: perPageForResponse,
+      hasMore: offset + perPage < clonedAgents.length
+    };
+  }
+  sortAgents(agents, field, direction) {
+    return agents.sort((a, b) => {
+      const aValue = new Date(a[field]).getTime();
+      const bValue = new Date(b[field]).getTime();
+      return direction === "ASC" ? aValue - bValue : bValue - aValue;
+    });
+  }
 };
 
 // src/storage/utils.ts
@@ -602,6 +889,57 @@ function safelyParseJSON(input) {
   }
   return {};
 }
+function transformRow(row, tableName, options = {}) {
+  const { preferredTimestampFields = {}, convertTimestamps = false, nullValuePattern, fieldMappings = {} } = options;
+  const tableSchema = TABLE_SCHEMAS[tableName];
+  const result = {};
+  for (const [key, columnSchema] of Object.entries(tableSchema)) {
+    const sourceKey = fieldMappings[key] ?? key;
+    let value = row[sourceKey];
+    if (preferredTimestampFields[key]) {
+      value = row[preferredTimestampFields[key]] ?? value;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (nullValuePattern && value === nullValuePattern) {
+      continue;
+    }
+    if (columnSchema.type === "jsonb") {
+      if (typeof value === "string") {
+        result[key] = safelyParseJSON(value);
+      } else if (typeof value === "object") {
+        result[key] = value;
+      } else {
+        result[key] = value;
+      }
+    } else if (columnSchema.type === "timestamp" && convertTimestamps && typeof value === "string") {
+      result[key] = new Date(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function transformScoreRow(row, options = {}) {
+  return transformRow(row, TABLE_SCORERS, options);
+}
+function toUpperSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function createStoreErrorId(type, store, operation, status) {
+  const normalizedStore = toUpperSnakeCase(store);
+  const normalizedOperation = toUpperSnakeCase(operation);
+  const normalizedStatus = toUpperSnakeCase(status);
+  const typePrefix = type === "storage" ? "STORAGE" : "VECTOR";
+  return `MASTRA_${typePrefix}_${normalizedStore}_${normalizedOperation}_${normalizedStatus}`;
+}
+function createStorageErrorId(store, operation, status) {
+  return createStoreErrorId("storage", store, operation, status);
+}
+function createVectorErrorId(store, operation, status) {
+  return createStoreErrorId("vector", store, operation, status);
+}
 
 // src/storage/domains/memory/base.ts
 var MemoryStorage = class extends MastraBase {
@@ -705,8 +1043,12 @@ var InMemoryMemory = class extends MemoryStorage {
     page = 0,
     orderBy
   }) {
-    this.logger.debug(`MockStore: listMessages called for thread ${threadId}`);
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    this.logger.debug(`MockStore: listMessages called for threads ${threadIds.join(", ")}`);
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new Error("threadId must be a non-empty string or array of non-empty strings");
+    }
+    const threadIdSet = new Set(threadIds);
     const { field, direction } = this.parseOrderBy(orderBy, "ASC");
     const perPage = normalizePerPage(perPageInput, 40);
     if (page < 0) {
@@ -718,7 +1060,7 @@ var InMemoryMemory = class extends MemoryStorage {
     }
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
     let threadMessages = Array.from(this.collection.messages.values()).filter((msg) => {
-      if (msg.thread_id !== threadId) return false;
+      if (!threadIdSet.has(msg.thread_id)) return false;
       if (resourceId && msg.resourceId !== resourceId) return false;
       return true;
     });
@@ -1420,7 +1762,8 @@ var StoreOperationsInMemory = class extends StoreOperations {
       mastra_traces: /* @__PURE__ */ new Map(),
       mastra_resources: /* @__PURE__ */ new Map(),
       mastra_scorers: /* @__PURE__ */ new Map(),
-      mastra_ai_spans: /* @__PURE__ */ new Map()
+      mastra_ai_spans: /* @__PURE__ */ new Map(),
+      mastra_agents: /* @__PURE__ */ new Map()
     };
   }
   getDatabase() {
@@ -1659,6 +2002,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
       snapshot = {
         context: {},
         activePaths: [],
+        activeStepsPath: {},
         timestamp: Date.now(),
         suspendedPaths: {},
         resumeLabels: {},
@@ -1699,6 +2043,7 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
       snapshot = {
         context: {},
         activePaths: [],
+        activeStepsPath: {},
         timestamp: Date.now(),
         suspendedPaths: {},
         resumeLabels: {},
@@ -1761,13 +2106,32 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     toDate,
     perPage,
     page,
-    resourceId
+    resourceId,
+    status
   } = {}) {
     if (page !== void 0 && page < 0) {
       throw new Error("page must be >= 0");
     }
     let runs = Array.from(this.collection.values());
     if (workflowName) runs = runs.filter((run) => run.workflow_name === workflowName);
+    if (status) {
+      runs = runs.filter((run) => {
+        let snapshot = run?.snapshot;
+        if (!snapshot) {
+          return false;
+        }
+        if (typeof snapshot === "string") {
+          try {
+            snapshot = JSON.parse(snapshot);
+          } catch (error) {
+            return false;
+          }
+        } else {
+          snapshot = JSON.parse(JSON.stringify(snapshot));
+        }
+        return snapshot.status === status;
+      });
+    }
     if (fromDate && toDate) {
       runs = runs.filter(
         (run) => new Date(run.createdAt).getTime() >= fromDate.getTime() && new Date(run.createdAt).getTime() <= toDate.getTime()
@@ -1816,6 +2180,9 @@ var WorkflowsInMemory = class extends WorkflowsStorage {
     };
     return parsedRun;
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    this.collection.delete(`${workflowName}-${runId}`);
+  }
 };
 
 // src/storage/mock.ts
@@ -1845,12 +2212,17 @@ var InMemoryStore = class extends MastraStorage {
       collection: database.mastra_ai_spans,
       operations: operationsStorage
     });
+    const agentsCollection = /* @__PURE__ */ new Map();
+    const agentsStorage = new InMemoryAgentsStorage({
+      collection: agentsCollection
+    });
     this.stores = {
       operations: operationsStorage,
       workflows: workflowsStorage,
       scores: scoresStorage,
       memory: memoryStorage,
-      observability: observabilityStorage
+      observability: observabilityStorage,
+      agents: agentsStorage
     };
   }
   get supports() {
@@ -1862,7 +2234,8 @@ var InMemoryStore = class extends MastraStorage {
       deleteMessages: true,
       observabilityInstance: true,
       indexManagement: false,
-      listScoresBySpan: true
+      listScoresBySpan: true,
+      agents: true
     };
   }
   async persistWorkflowSnapshot({
@@ -2005,6 +2378,9 @@ var InMemoryStore = class extends MastraStorage {
   }) {
     return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
+  }
   async createSpan(span) {
     return this.stores.observability.createSpan(span);
   }
@@ -2026,6 +2402,6 @@ var InMemoryStore = class extends MastraStorage {
 };
 var MockStore = InMemoryStore;
 
-export { InMemoryMemory, InMemoryStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, SCORERS_SCHEMA, SPAN_SCHEMA, ScoresInMemory, ScoresStorage, StoreOperations, StoreOperationsInMemory, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEMAS, TABLE_SCORERS, TABLE_SPANS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, WorkflowsInMemory, WorkflowsStorage, calculatePagination, ensureDate, normalizePerPage, safelyParseJSON, serializeDate };
-//# sourceMappingURL=chunk-MV7KHWUT.js.map
-//# sourceMappingURL=chunk-MV7KHWUT.js.map
+export { AGENTS_SCHEMA, AgentsStorage, InMemoryAgentsStorage, InMemoryMemory, InMemoryStore, MastraStorage, MemoryStorage, MockStore, ObservabilityInMemory, ObservabilityStorage, SCORERS_SCHEMA, SPAN_SCHEMA, ScoresInMemory, ScoresStorage, StoreOperations, StoreOperationsInMemory, TABLE_AGENTS, TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCHEMAS, TABLE_SCORERS, TABLE_SPANS, TABLE_THREADS, TABLE_TRACES, TABLE_WORKFLOW_SNAPSHOT, WorkflowsInMemory, WorkflowsStorage, calculatePagination, createStorageErrorId, createStoreErrorId, createVectorErrorId, ensureDate, normalizePerPage, safelyParseJSON, serializeDate, transformRow, transformScoreRow };
+//# sourceMappingURL=chunk-JIGDJK2O.js.map
+//# sourceMappingURL=chunk-JIGDJK2O.js.map