@mastra/editor 0.10.2-alpha.0 → 0.11.0-alpha.2

package/dist/index.js

@@ -1,5 +1,6 @@
 // src/index.ts
 import { BUILT_IN_PROCESSOR_PROVIDERS } from "@mastra/core/processor-provider";
+import { UnknownToolProviderError } from "@mastra/core/tool-provider";
 
 // src/namespaces/base.ts
 var EditorNamespace = class {
@@ -126,6 +127,7 @@ import { Agent } from "@mastra/core/agent";
 import { CompositeVersionedSkillSource } from "@mastra/core/workspace";
 import { convertSchemaToZod } from "@mastra/schema-compat";
 import { RequestContext } from "@mastra/core/request-context";
+import { resolveStoredToolProviders } from "@mastra/core/tool-provider";
 
 // src/rule-evaluator.ts
 function resolvePath(context, path) {
@@ -731,11 +733,13 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasStoredTools = storedConfig.tools != null;
     const hasStoredMCPClients = storedConfig.mcpClients != null;
     const hasStoredIntegrationTools = storedConfig.integrationTools != null;
-    if (hasStoredTools || hasStoredMCPClients || hasStoredIntegrationTools) {
+    const hasStoredToolProviders = storedConfig.toolProviders != null && Object.keys(storedConfig.toolProviders).length > 0;
+    if (hasStoredTools || hasStoredMCPClients || hasStoredIntegrationTools || hasStoredToolProviders) {
       const hasConditionalTools = this.isConditionalVariants(storedConfig.tools);
       const hasConditionalMCPClients = storedConfig.mcpClients != null && this.isConditionalVariants(storedConfig.mcpClients);
       const hasConditionalIntegrationTools = storedConfig.integrationTools != null && this.isConditionalVariants(storedConfig.integrationTools);
-      const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools || hasStoredIntegrationTools;
+      const hasConditionalToolProviders = storedConfig.toolProviders != null && this.isConditionalVariants(storedConfig.toolProviders);
+      const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools || hasStoredIntegrationTools || hasConditionalToolProviders || hasStoredToolProviders;
       if (isDynamicTools) {
         const originalTools = agent.listTools.bind(agent);
         const toolsFn = async ({ requestContext: requestContext2 }) => {
@@ -759,7 +763,20 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
             resolvedIntegrationToolsConfig,
             requestContext2
           );
-          return { ...codeTools, ...registryTools, ...mcpTools, ...integrationTools };
+          const resolvedToolProvidersConfig = hasConditionalToolProviders ? this.accumulateObjectVariants(
+            storedConfig.toolProviders,
+            ctx
+          ) : storedConfig.toolProviders;
+          const providerTools = await resolveStoredToolProviders(
+            resolvedToolProvidersConfig,
+            (providerId) => this.editor.getToolProviderOrThrow(providerId),
+            {
+              requestContext: ctx,
+              authorId: storedConfig.authorId,
+              logger: this.logger
+            }
+          );
+          return { ...codeTools, ...registryTools, ...mcpTools, ...integrationTools, ...providerTools };
         };
         fork.__setTools(toolsFn);
       } else {
@@ -831,6 +848,8 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasConditionalTools = storedAgent.tools != null && this.isConditionalVariants(storedAgent.tools);
     const hasConditionalMCPClients = storedAgent.mcpClients != null && this.isConditionalVariants(storedAgent.mcpClients);
     const hasConditionalIntegrationTools = storedAgent.integrationTools != null && this.isConditionalVariants(storedAgent.integrationTools);
+    const hasToolProviders = storedAgent.toolProviders != null && Object.keys(storedAgent.toolProviders).length > 0;
+    const hasConditionalToolProviders = storedAgent.toolProviders != null && this.isConditionalVariants(storedAgent.toolProviders);
     const hasConditionalWorkflows = storedAgent.workflows != null && this.isConditionalVariants(storedAgent.workflows);
     const hasConditionalAgents = storedAgent.agents != null && this.isConditionalVariants(storedAgent.agents);
     const hasConditionalMemory = storedAgent.memory != null && this.isConditionalVariants(storedAgent.memory);
@@ -842,7 +861,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasConditionalWorkspace = storedAgent.workspace != null && this.isConditionalVariants(storedAgent.workspace);
     const hasConditionalBrowser = storedAgent.browser != null && this.isConditionalVariants(storedAgent.browser);
     const hasIntegrationTools = storedAgent.integrationTools != null;
-    const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools || hasIntegrationTools;
+    const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools || hasIntegrationTools || hasConditionalToolProviders || hasToolProviders;
     let tools;
     if (isDynamicTools) {
       tools = async ({ requestContext }) => {
@@ -865,7 +884,17 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
           resolvedIntegrationToolsConfig,
           requestContext
         );
-        return { ...registryTools, ...mcpTools, ...integrationTools };
+        const resolvedToolProvidersConfig = hasConditionalToolProviders ? this.accumulateObjectVariants(storedAgent.toolProviders, ctx) : storedAgent.toolProviders;
+        const providerTools = await resolveStoredToolProviders(
+          resolvedToolProvidersConfig,
+          (providerId) => this.editor.getToolProviderOrThrow(providerId),
+          {
+            requestContext: ctx,
+            authorId: storedAgent.authorId,
+            logger: this.logger
+          }
+        );
+        return { ...registryTools, ...mcpTools, ...integrationTools, ...providerTools };
       };
     } else {
       const registryTools = this.resolveStoredTools(storedAgent.tools);
@@ -2374,9 +2403,7 @@ var MastraEditor = class {
   getToolProviderOrThrow(id) {
     const provider = this.__toolProviders[id];
     if (!provider) {
-      throw new Error(
-        `Unknown tool provider "${id}". Available: ${Object.keys(this.__toolProviders).join(", ") || "(none)"}`
-      );
+      throw new UnknownToolProviderError(id, Object.keys(this.__toolProviders));
     }
     return provider;
   }