@mastra/core 1.2.1-alpha.0 → 1.3.0-alpha.2

package/dist/{chunk-RXD5EGQF.js → chunk-VVD56FI4.js}

@@ -1,12 +1,12 @@
-import { WorkflowEventProcessor } from './chunk-5YVR7B4R.js';
-import { isToolLoopAgentLike, toolLoopAgentToMastraAgent } from './chunk-ZWM2CAIM.js';
-import { createOnScorerHook } from './chunk-MSWXEOZC.js';
-import { EventEmitterPubSub, augmentWithInit } from './chunk-WFUNLRQX.js';
+import { WorkflowEventProcessor } from './chunk-JQNREL64.js';
+import { isToolLoopAgentLike, toolLoopAgentToMastraAgent } from './chunk-STKNQDVA.js';
+import { createOnScorerHook } from './chunk-KL2JPSRX.js';
+import { EventEmitterPubSub, augmentWithInit } from './chunk-ZRUTE56J.js';
 import { noopLogger } from './chunk-PSCMWPLC.js';
 import { registerHook } from './chunk-L54GIUCB.js';
 import { NoOpObservability } from './chunk-Y3TQ52UE.js';
 import { MastraError } from './chunk-FJEVLHJT.js';
-import { InMemoryServerCache } from './chunk-M6VFJX5A.js';
+import { InMemoryServerCache } from './chunk-GMSAGYTB.js';
 import { ConsoleLogger, LogLevel } from './chunk-X2WMFSPB.js';
 import { randomUUID } from 'crypto';
 
@@ -37,6 +37,7 @@ var Mastra = class {
   #processorConfigurations = /* @__PURE__ */ new Map();
   #memory;
   #workspace;
+  #workspaces = {};
   #server;
   #serverAdapter;
   #mcpServers;
@@ -50,6 +51,10 @@ var Mastra = class {
   #serverCache;
   // Cache for stored agents to allow in-memory modifications (like model changes) to persist across requests
   #storedAgentsCache = /* @__PURE__ */ new Map();
+  // Cache for stored scorers to allow in-memory modifications to persist across requests
+  #storedScorersCache = /* @__PURE__ */ new Map();
+  // Registry for prompt blocks (stored or code-defined)
+  #promptBlocks = {};
   // Editor instance for handling agent instantiation and configuration
   #editor;
   get pubsub() {
@@ -92,6 +97,13 @@ var Mastra = class {
   getStoredAgentCache() {
     return this.#storedAgentsCache;
   }
+  /**
+   * Gets the stored scorers cache
+   * @internal
+   */
+  getStoredScorerCache() {
+    return this.#storedScorersCache;
+  }
   /**
    * Generates a unique identifier using the configured generator or defaults to `crypto.randomUUID()`.
    *
@@ -283,6 +295,7 @@ var Mastra = class {
     }
     if (config?.workspace) {
       this.#workspace = config.workspace;
+      this.addWorkspace(config.workspace);
     }
     if (config?.scorers) {
       Object.entries(config.scorers).forEach(([key, scorer]) => {
@@ -505,6 +518,22 @@ var Mastra = class {
     }).catch((err) => {
       this.#logger?.debug(`Failed to register processor workflows for agent ${agentKey}:`, err);
     });
+    if (mastraAgent.hasOwnWorkspace?.()) {
+      Promise.resolve(mastraAgent.getWorkspace?.()).then((workspace) => {
+        if (workspace) {
+          this.addWorkspace(workspace);
+        }
+      }).catch((err) => {
+        this.#logger?.debug(`Failed to register workspace for agent ${agentKey}:`, err);
+      });
+    }
+    mastraAgent.listScorers().then((scorers) => {
+      for (const [, entry] of Object.entries(scorers || {})) {
+        this.addScorer(entry.scorer);
+      }
+    }).catch((err) => {
+      this.#logger?.debug(`Failed to register scorers from agent ${agentKey}:`, err);
+    });
   }
   /**
    * Removes an agent from the Mastra instance by its key or ID.
@@ -747,6 +776,78 @@ var Mastra = class {
   getWorkspace() {
     return this.#workspace;
   }
+  /**
+   * Retrieves a registered workspace by its ID.
+   *
+   * @throws {MastraError} When the workspace with the specified ID is not found
+   *
+   * @example
+   * ```typescript
+   * const workspace = mastra.getWorkspaceById('workspace-123');
+   * const files = await workspace.filesystem.readdir('/');
+   * ```
+   */
+  getWorkspaceById(id) {
+    const workspace = this.#workspaces[id];
+    if (!workspace) {
+      const error = new MastraError({
+        id: "MASTRA_GET_WORKSPACE_BY_ID_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Workspace with id ${id} not found`,
+        details: {
+          status: 404,
+          workspaceId: id,
+          availableIds: Object.keys(this.#workspaces).join(", ")
+        }
+      });
+      this.#logger?.trackException(error);
+      throw error;
+    }
+    return workspace;
+  }
+  /**
+   * Returns all registered workspaces as a record keyed by their IDs.
+   *
+   * @example
+   * ```typescript
+   * const workspaces = mastra.listWorkspaces();
+   * for (const [id, workspace] of Object.entries(workspaces)) {
+   *   console.log(`Workspace ${id}: ${workspace.name}`);
+   * }
+   * ```
+   */
+  listWorkspaces() {
+    return { ...this.#workspaces };
+  }
+  /**
+   * Adds a new workspace to the Mastra instance.
+   *
+   * This method allows dynamic registration of workspaces after the Mastra instance
+   * has been created. Workspaces are keyed by their ID.
+   *
+   * @example
+   * ```typescript
+   * const workspace = new Workspace({
+   *   id: 'project-workspace',
+   *   name: 'Project Workspace',
+   *   filesystem: new LocalFilesystem({ rootPath: './workspace' })
+   * });
+   * mastra.addWorkspace(workspace);
+   * ```
+   */
+  addWorkspace(workspace, key) {
+    if (!workspace) {
+      throw createUndefinedPrimitiveError("workspace", workspace, key);
+    }
+    const workspaceKey = key || workspace.id;
+    if (this.#workspaces[workspaceKey]) {
+      const logger = this.getLogger();
+      logger.debug(`Workspace with key ${workspaceKey} already exists. Skipping addition.`);
+      return;
+    }
+    this.#workspaces[workspaceKey] = workspace;
+  }
   /**
    * Retrieves a registered workflow by its ID.
    *
@@ -961,7 +1062,7 @@ var Mastra = class {
    * mastra.addScorer(newScorer, 'customKey'); // Uses custom key
    * ```
    */
-  addScorer(scorer, key) {
+  addScorer(scorer, key, options) {
     if (!scorer) {
       throw createUndefinedPrimitiveError("scorer", scorer, key);
     }
@@ -973,6 +1074,9 @@ var Mastra = class {
       return;
     }
     scorer.__registerMastra(this);
+    if (options?.source) {
+      scorer.source = options.source;
+    }
     scorers[scorerKey] = scorer;
   }
   /**
@@ -1067,52 +1171,111 @@ var Mastra = class {
     this.#logger?.trackException(error);
     throw error;
   }
-  // NOTE: Stored scorer methods are commented out until the storage infrastructure is added in PR2
-  // /**
-  //  * Retrieves a stored scorer by its ID from the database.
-  //  */
-  // public async getStoredScorerById(id: string): Promise<StoredScorerType | null> {
-  //   // Implementation will be added in PR2
-  //   throw new Error('Stored scorers not yet implemented');
-  // }
-  // /**
-  //  * Lists all stored scorers from the database with optional pagination.
-  //  */
-  // public async listStoredScorers(args?: {
-  //   page?: number;
-  //   perPage?: number | false;
-  //   orderBy?: { field: 'createdAt' | 'updatedAt'; direction: 'ASC' | 'DESC' };
-  // }): Promise<{
-  //   scorers: StoredScorerType[];
-  //   total: number;
-  //   page: number;
-  //   perPage: number | false;
-  //   hasMore: boolean;
-  // }> {
-  //   // Implementation will be added in PR2
-  //   throw new Error('Stored scorers not yet implemented');
-  // }
-  // /**
-  //  * Retrieves and resolves a stored scorer from the database into an executable MastraScorer.
-  //  */
-  // public async resolveStoredScorer(id: string): Promise<MastraScorer | null> {
-  //   // Implementation will be added in PR2
-  //   return null;
-  // }
-  // /**
-  //  * Unified method to get a scorer by ID, checking code-defined scorers first,
-  //  * then falling back to stored scorers from the database.
-  //  */
-  // public async getScorerUnified(id: string): Promise<MastraScorer | null> {
-  //   // First, try to find in code-defined scorers
-  //   try {
-  //     const scorer = this.getScorerById(id);
-  //     return scorer;
-  //   } catch {
-  //     // Stored scorers will be added in PR2
-  //     return null;
-  //   }
-  // }
+  /**
+   * Removes a scorer from the Mastra instance by its key or ID.
+   *
+   * @param keyOrId - The scorer key or ID to remove
+   * @returns true if a scorer was removed, false if no scorer was found
+   */
+  removeScorer(keyOrId) {
+    const scorers = this.#scorers;
+    if (!scorers) return false;
+    if (scorers[keyOrId]) {
+      const scorerId = scorers[keyOrId]?.id;
+      delete scorers[keyOrId];
+      if (scorerId) {
+        this.#storedScorersCache.delete(scorerId);
+      }
+      return true;
+    }
+    const key = Object.keys(scorers).find((k) => scorers[k]?.id === keyOrId || scorers[k]?.name === keyOrId);
+    if (key) {
+      const scorerId = scorers[key]?.id;
+      delete scorers[key];
+      if (scorerId) {
+        this.#storedScorersCache.delete(scorerId);
+      }
+      return true;
+    }
+    return false;
+  }
+  // =========================================================================
+  // Prompt Blocks
+  // =========================================================================
+  /**
+   * Returns all registered prompt blocks.
+   */
+  listPromptBlocks() {
+    return this.#promptBlocks;
+  }
+  /**
+   * Registers a prompt block in the Mastra instance's runtime registry.
+   *
+   * @param promptBlock - The resolved prompt block to register
+   * @param key - Optional registration key (defaults to promptBlock.id)
+   */
+  addPromptBlock(promptBlock, key) {
+    const blockKey = key || promptBlock.id;
+    if (this.#promptBlocks[blockKey]) {
+      const logger = this.getLogger();
+      logger.debug(`Prompt block with key ${blockKey} already exists. Skipping addition.`);
+      return;
+    }
+    this.#promptBlocks[blockKey] = promptBlock;
+  }
+  /**
+   * Retrieves a registered prompt block by its key.
+   *
+   * @throws {MastraError} When the prompt block with the specified key is not found
+   */
+  getPromptBlock(key) {
+    const block = this.#promptBlocks[key];
+    if (!block) {
+      throw new MastraError({
+        id: "MASTRA_GET_PROMPT_BLOCK_NOT_FOUND",
+        domain: "MASTRA" /* MASTRA */,
+        category: "USER" /* USER */,
+        text: `Prompt block with key ${key} not found`
+      });
+    }
+    return block;
+  }
+  /**
+   * Retrieves a registered prompt block by its ID.
+   *
+   * @throws {MastraError} When no prompt block is found with the specified ID
+   */
+  getPromptBlockById(id) {
+    for (const [, block] of Object.entries(this.#promptBlocks)) {
+      if (block.id === id) {
+        return block;
+      }
+    }
+    throw new MastraError({
+      id: "MASTRA_GET_PROMPT_BLOCK_BY_ID_NOT_FOUND",
+      domain: "MASTRA" /* MASTRA */,
+      category: "USER" /* USER */,
+      text: `Prompt block with id ${id} not found`
+    });
+  }
+  /**
+   * Removes a prompt block from the Mastra instance by its key or ID.
+   *
+   * @param keyOrId - The prompt block key or ID to remove
+   * @returns true if a prompt block was removed, false if not found
+   */
+  removePromptBlock(keyOrId) {
+    if (this.#promptBlocks[keyOrId]) {
+      delete this.#promptBlocks[keyOrId];
+      return true;
+    }
+    const key = Object.keys(this.#promptBlocks).find((k) => this.#promptBlocks[k]?.id === keyOrId);
+    if (key) {
+      delete this.#promptBlocks[key];
+      return true;
+    }
+    return false;
+  }
   /**
    * Retrieves a specific tool by registration key.
    *
@@ -1679,12 +1842,22 @@ var Mastra = class {
         this.#mcpServers?.[key]?.__setLogger(this.#logger);
       });
     }
+    if (this.#workflows) {
+      Object.keys(this.#workflows).forEach((key) => {
+        this.#workflows?.[key]?.__setLogger(this.#logger);
+      });
+    }
     if (this.#serverAdapter) {
       this.#serverAdapter.__setLogger(this.#logger);
     }
     if (this.#workspace) {
       this.#workspace.__setLogger(this.#logger);
     }
+    if (this.#memory) {
+      Object.keys(this.#memory).forEach((key) => {
+        this.#memory?.[key]?.__setLogger(this.#logger);
+      });
+    }
     this.#observability.setLogger({ logger: this.#logger });
   }
   /**
@@ -2314,7 +2487,7 @@ var Mastra = class {
       if (process.env.MASTRA_DEV !== "true" && process.env.MASTRA_DEV !== "1") {
         return;
       }
-      import('./provider-registry-RPOTQNHI.js').then(async ({ GatewayRegistry }) => {
+      import('./provider-registry-NWU4YFQW.js').then(async ({ GatewayRegistry }) => {
         const registry = GatewayRegistry.getInstance();
         const customGateways = Object.values(this.#gateways || {});
         registry.registerCustomGateways(customGateways);
@@ -2368,5 +2541,5 @@ var Mastra = class {
 };
 
 export { Mastra };
-//# sourceMappingURL=chunk-RXD5EGQF.js.map
-//# sourceMappingURL=chunk-RXD5EGQF.js.map
+//# sourceMappingURL=chunk-VVD56FI4.js.map
+//# sourceMappingURL=chunk-VVD56FI4.js.map