donobu 5.17.2 → 5.18.0

package/dist/esm/codegen/CodeGenerator.js

@@ -49,7 +49,6 @@ const cache_1 = require("../lib/ai/cache/cache");
 const cacheEntryBuilder_1 = require("../lib/ai/cache/cacheEntryBuilder");
 const cacheLocator_1 = require("../lib/ai/cache/cacheLocator");
 const DonobuFlowsManager_1 = require("../managers/DonobuFlowsManager");
-const ToolManager_1 = require("../managers/ToolManager");
 const GptConfig_1 = require("../models/GptConfig");
 const AnalyzePageTextTool_1 = require("../tools/AnalyzePageTextTool");
 const AssertPageTool_1 = require("../tools/AssertPageTool");
@@ -83,8 +82,38 @@ function getLocalPlaywrightVersion() {
     return pkgJson.version;
 }
 const PLAYWRIGHT_VERSION = getLocalPlaywrightVersion();
+/**
+ * Computes the `allowedTools` and `maxToolCalls` values as they will appear at
+ * runtime when the generated test code is executed by `PageAi.buildDescriptor`.
+ *
+ * The generated test code only emits an explicit `allowedTools` option when the
+ * flow uses non-default tools, and omits `maxToolCalls` when it equals the
+ * default. At runtime the omitted values fall back to `[]` and
+ * `DEFAULT_MAX_TOOL_CALLS` respectively. The cache lock file must store these
+ * same resolved values so that the cache key matches on the first run.
+ */
+function computeRuntimeCacheKeyFields(toolCalls, defaultToolNames, minimalToolNames, maxToolCalls) {
+    const toolNamesFromCalls = Array.from(new Set(toolCalls.map((tc) => tc.name)))
+        .filter((name) => !minimalToolNames.has(name))
+        .sort();
+    const usesNonDefaultTool = toolNamesFromCalls.some((name) => !defaultToolNames.has(name));
+    // Mirror the runtime defaulting in PageAi.buildDescriptor:
+    //   options?.allowedTools ?? []
+    const resolvedAllowedTools = usesNonDefaultTool && toolNamesFromCalls.length > 0
+        ? toolNamesFromCalls
+        : [];
+    // Mirror: options?.maxToolCalls ?? DEFAULT_MAX_TOOL_CALLS
+    const resolvedMaxToolCalls = maxToolCalls !== null &&
+        maxToolCalls !== DonobuFlowsManager_1.DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS
+        ? maxToolCalls
+        : DonobuFlowsManager_1.DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS;
+    return {
+        allowedTools: resolvedAllowedTools,
+        maxToolCalls: resolvedMaxToolCalls,
+    };
+}
 /** Creates a Node.js Microsoft Playwright script to replay the given flow. */
-async function getFlowAsPlaywrightScript(flowMetadata, toolCalls, options) {
+async function getFlowAsPlaywrightScript(flowMetadata, toolCalls, options = {}, toolRegistry) {
     // These tools are not supported in the generated script because they have
     // static outputs that have no side effects, so they are not actually
     // doing anything.
@@ -100,7 +129,7 @@ async function getFlowAsPlaywrightScript(flowMetadata, toolCalls, options) {
             description: env,
         };
     });
-    const allTools = await ToolManager_1.ToolManager.allTools();
+    const allTools = toolRegistry.allTools();
     const gptClientRequired = isGptClientRequired(flowMetadata, toolCalls, allTools);
     const gptSetupNote = gptClientRequired
         ? `* Note that this test uses tools that require the usage of an LLM, so be
@@ -174,7 +203,7 @@ ${resultJson}
     return prettifyCode(script);
 }
 /** Creates a Node.js Microsoft Playwright script to replay the given flow. */
-async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options) {
+async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options, toolRegistry) {
     const [firstToolCall, ...remaingToolCalls] = toolCalls;
     // If the first tool call is "GoToWebpage", then we peel it off and treat it
     // specially.
@@ -207,16 +236,10 @@ async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options) {
     const annotationsLiteral = annotations.length > 0
         ? JSON.stringify({ annotation: annotations }, null, 2)
         : null;
-    const defaultToolNames = new Set((await ToolManager_1.ToolManager.defaultTools()).map((tool) => tool.name));
-    const minimalTools = new Set((await ToolManager_1.ToolManager.minimalTools()).map((t) => t.name));
-    const toolNamesFromCalls = Array.from(new Set((specialCaseGoto ? remaingToolCalls : toolCalls).map((tc) => tc.name)))
-        .filter((tc) => {
-        // We can exclude minimal tools since they will automatically be included
-        // when running any flow anyway, so no need to muck up the code by specifying them.
-        return !minimalTools.has(tc);
-    })
-        .sort();
-    const usesNonDefaultTool = toolNamesFromCalls.some((toolName) => !defaultToolNames.has(toolName));
+    const defaultToolNames = new Set(toolRegistry.defaultTools().map((tool) => tool.name));
+    const minimalToolNames = new Set(toolRegistry.minimalTools().map((t) => t.name));
+    const effectiveToolCalls = specialCaseGoto ? remaingToolCalls : toolCalls;
+    const runtimeFields = computeRuntimeCacheKeyFields(effectiveToolCalls, defaultToolNames, minimalToolNames, flowMetadata.maxToolCalls);
     const donobuImports = ['test'];
     if (flowMetadata.resultJsonSchema !== null) {
         donobuImports.push('jsonSchemaToZod');
@@ -225,12 +248,11 @@ async function getFlowAsAiPlaywrightScript(flowMetadata, toolCalls, options) {
     if (flowMetadata.resultJsonSchema) {
         optionsLines.push(`schema: jsonSchemaToZod(${JSON.stringify(flowMetadata.resultJsonSchema)})`);
     }
-    if (usesNonDefaultTool && toolNamesFromCalls.length > 0) {
-        optionsLines.push(`allowedTools: ${JSON.stringify(toolNamesFromCalls)}`);
+    if (runtimeFields.allowedTools.length > 0) {
+        optionsLines.push(`allowedTools: ${JSON.stringify(runtimeFields.allowedTools)}`);
     }
-    if (flowMetadata.maxToolCalls !== null &&
-        flowMetadata.maxToolCalls !== DonobuFlowsManager_1.DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS) {
-        optionsLines.push(`maxToolCalls: ${flowMetadata.maxToolCalls}`);
+    if (runtimeFields.maxToolCalls !== DonobuFlowsManager_1.DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS) {
+        optionsLines.push(`maxToolCalls: ${runtimeFields.maxToolCalls}`);
     }
     if (flowMetadata.envVars && flowMetadata.envVars.length > 0) {
         optionsLines.push(`envVars: ${JSON.stringify(flowMetadata.envVars)}`);
@@ -271,7 +293,7 @@ ${aiInvocation}
  * Browser state dependencies are materialized as static JSON files
  * and referenced via storageState paths in the Playwright config.
  */
-async function generateProject(flowsWithToolCalls, resolvedBrowserStates, gptConfig, options) {
+async function generateProject(flowsWithToolCalls, resolvedBrowserStates, gptConfig, options, toolRegistry) {
     const flowsMetadata = flowsWithToolCalls.map((f) => f.metadata);
     const files = [];
     // Generate browser state JSON files and build a path map for the config.
@@ -292,7 +314,7 @@ async function generateProject(flowsWithToolCalls, resolvedBrowserStates, gptCon
     }
     const hasBrowserStates = browserStateEntries.length > 0;
     // Generate individual test files
-    const testFiles = await generateTestFiles(flowsWithToolCalls, options);
+    const testFiles = await generateTestFiles(flowsWithToolCalls, options, toolRegistry);
     files.push(...testFiles);
     // Generate playwright.config.ts
     files.push({
@@ -301,7 +323,7 @@ async function generateProject(flowsWithToolCalls, resolvedBrowserStates, gptCon
     });
     files.push({
         path: '.github/workflows/run-tests.yml',
-        content: await generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options, hasBrowserStates),
+        content: await generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options, hasBrowserStates, toolRegistry),
     });
     // Generate package.json if needed
     files.push({
@@ -318,17 +340,17 @@ async function generateProject(flowsWithToolCalls, resolvedBrowserStates, gptCon
         content: generateGitIgnore(),
     });
     const cacheFiles = options.playwrightScriptVariant === 'ai'
-        ? await buildCacheFiles(flowsWithToolCalls)
+        ? await buildCacheFiles(flowsWithToolCalls, toolRegistry)
         : [];
     files.push(...cacheFiles);
     return { files };
 }
-async function generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options, hasBrowserStates = false) {
+async function generateGitHubActionsWorkflow(flowsWithToolCalls, gptConfig, options, hasBrowserStates = false, toolRegistry) {
     const flowsMetadata = flowsWithToolCalls.map((f) => f.metadata);
     const allUniqueEnvVars = [
         ...new Set(flowsMetadata.flatMap((flow) => flow.envVars || [])),
     ];
-    const allTools = await ToolManager_1.ToolManager.allTools();
+    const allTools = toolRegistry.allTools();
     const gptClientRequired = flowsWithToolCalls.some((f) => {
         return isGptClientRequired(f.metadata, f.toolCalls, allTools);
     }) || !options.disableSelfHealingTests;
@@ -464,7 +486,9 @@ ${xvfbStep}
           fi
 ${pullRequestCreationSection}`;
 }
-function buildCacheContents(flowsWithToolCalls) {
+async function buildCacheContents(flowsWithToolCalls, toolRegistry) {
+    const defaultToolNames = new Set(toolRegistry.defaultTools().map((tool) => tool.name));
+    const minimalToolNames = new Set(toolRegistry.minimalTools().map((t) => t.name));
     const entries = flowsWithToolCalls
         // We can only create page.ai caches for flows that have an objective.
         .filter(({ metadata }) => metadata.overallObjective?.trim() && metadata.runMode === 'AUTONOMOUS')
@@ -487,9 +511,14 @@ function buildCacheContents(flowsWithToolCalls) {
             pageUrlForCache = metadata.web?.targetWebsite ?? '';
         }
         const cacheEntry = cacheEntryBuilder_1.PageAiCacheEntryBuilder.fromMetadata(pageUrlForCache, metadata, toolCallsForCache);
+        // Compute allowedTools and maxToolCalls as the runtime will see them,
+        // so the cache lock file keys match the keys built by PageAi.buildDescriptor
+        // when the generated test code is executed.
+        const runtimeFields = computeRuntimeCacheKeyFields(toolCallsForCache, defaultToolNames, minimalToolNames, metadata.maxToolCalls);
         return {
             ...cacheEntry,
-            allowedTools: [...cacheEntry.allowedTools],
+            allowedTools: runtimeFields.allowedTools,
+            maxToolCalls: runtimeFields.maxToolCalls,
             schema: cacheEntry.schema === null
                 ? null
                 : JSON.parse(JSON.stringify(cacheEntry.schema)),
@@ -499,10 +528,10 @@ function buildCacheContents(flowsWithToolCalls) {
         caches: entries,
     };
 }
-async function buildCacheFiles(flowsWithToolCalls) {
+async function buildCacheFiles(flowsWithToolCalls, toolRegistry) {
     const files = [];
     for (const flow of flowsWithToolCalls) {
-        const contents = buildCacheContents([flow]);
+        const contents = await buildCacheContents([flow], toolRegistry);
         if (contents.caches.length === 0) {
             continue;
         }
@@ -776,7 +805,7 @@ function generateProjectConfig(projectName, flow, storageStatePath) {
 /**
  * Generates test files for all flows
  */
-async function generateTestFiles(flowsWithToolCalls, options) {
+async function generateTestFiles(flowsWithToolCalls, options, toolRegistry) {
     const files = [];
     const scriptVariant = options.playwrightScriptVariant === 'classic' ? 'classic' : 'ai';
     for (const { metadata, toolCalls } of flowsWithToolCalls) {
@@ -784,8 +813,8 @@ async function generateTestFiles(flowsWithToolCalls, options) {
         const content = scriptVariant === 'classic' ||
             !metadata.overallObjective?.trim() ||
             metadata.runMode !== 'AUTONOMOUS'
-            ? await getFlowAsPlaywrightScript(metadata, toolCalls, options)
-            : await getFlowAsAiPlaywrightScript(metadata, toolCalls, options);
+            ? await getFlowAsPlaywrightScript(metadata, toolCalls, options, toolRegistry)
+            : await getFlowAsAiPlaywrightScript(metadata, toolCalls, options, toolRegistry);
         files.push({
             path: `tests/${fileName}`,
             content,

package/dist/esm/lib/ai/PageAi.js

@@ -105,11 +105,12 @@ class PageAiRunner {
      * a narrower list.
      */
     async buildToolManager(allowedToolsByName) {
+        const registry = this.donobu.toolRegistry;
         if (allowedToolsByName.length === 0) {
-            return new ToolManager_1.ToolManager(await ToolManager_1.ToolManager.defaultTools());
+            return new ToolManager_1.ToolManager(registry.defaultTools());
         }
-        const allTools = await ToolManager_1.ToolManager.allTools();
-        const minimalToolsByName = (await ToolManager_1.ToolManager.minimalTools()).map((t) => t.name);
+        const allTools = registry.allTools();
+        const minimalToolsByName = registry.minimalTools().map((t) => t.name);
         const semifinalToolNames = new Set([
             ...allowedToolsByName,
             ...minimalToolsByName,

package/dist/esm/lib/page/extendPage.js

@@ -489,7 +489,7 @@ async function runTool(page, toolName, toolParams, gptClient) {
         metadata: page._dnb.donobuFlowMetadata,
         toolCallId: clonedParams.toolCallId ?? MiscUtils_1.MiscUtils.createAdHocToolCallId(),
     };
-    const tools = await ToolManager_1.ToolManager.allTools();
+    const tools = page._dnb.donobuStack.toolRegistry.allTools();
     const result = await new ToolManager_1.ToolManager(tools).invokeTool(toolCallContext, toolName, clonedParams, false);
     return result;
 }

package/dist/esm/lib/test/utils/selfHealing.js

@@ -37,7 +37,6 @@ exports.selfHeal = selfHeal;
 const fs = __importStar(require("fs"));
 const v4_1 = require("zod/v4");
 const DonobuFlowsManager_1 = require("../../../managers/DonobuFlowsManager");
-const ToolManager_1 = require("../../../managers/ToolManager");
 const CodeGenerationOptions_1 = require("../../../models/CodeGenerationOptions");
 const AnalyzePageTextTool_1 = require("../../../tools/AnalyzePageTextTool");
 const AssertPageTextTool_1 = require("../../../tools/AssertPageTextTool");
@@ -106,7 +105,7 @@ async function selfHeal(gptClient, testInfo, page) {
         testInfo.setTimeout(testInfo.timeout + selfHealTimeoutMs);
         Logger_1.appLogger.info(`Extending the test timeout ${selfHealTimeoutMs}ms for self-healing...`);
         Logger_1.appLogger.info('Attempting to self-heal by creating a new autonomous flow...');
-        const allowedTools = await buildToolList(donobuFlowMetadata);
+        const allowedTools = await buildToolList(donobuFlowMetadata, donobu.toolRegistry);
         const objectiveWhileSelfHealing = `
 Use tool calling to follow along with the intent of this Playwright test.
 The test had failed, so some parts may need to be adjusted along the way, but
@@ -267,7 +266,7 @@ to someone who is tasked with completing it as a goal.
         };
     }
 }
-async function buildToolList(donobuFlowMetadata) {
+async function buildToolList(donobuFlowMetadata, toolRegistry) {
     const baseTools = [
         AnalyzePageTextTool_1.AnalyzePageTextTool.NAME,
         AssertTool_1.AssertTool.NAME,
@@ -293,7 +292,7 @@ async function buildToolList(donobuFlowMetadata) {
         WaitTool_1.WaitTool.NAME,
     ];
     // Always allow tools from plugins.
-    const toolsFromPlugins = (await ToolManager_1.ToolManager.pluginTools()).map((t) => t.name);
+    const toolsFromPlugins = toolRegistry.pluginTools().map((t) => t.name);
     const defaultTools = new Set([
         ...(donobuFlowMetadata.allowedTools ? donobuFlowMetadata.allowedTools : []),
         ...baseTools,

package/dist/esm/main.d.ts

@@ -2,7 +2,7 @@ export { AnthropicGptClient } from './clients/AnthropicGptClient';
 export { DonobuGptClient } from './clients/DonobuGptClient';
 export { fixAssertFields, GoogleGenerativeAiGptClient, } from './clients/GoogleGenerativeAiGptClient';
 export { GptClient } from './clients/GptClient';
-export { type GptClientPlugin, registerGptClientPlugin, } from './clients/GptClientPlugin';
+export { type GptClientPlugin, GptClientPluginRegistry, } from './clients/GptClientPlugin';
 export { OpenAiGptClient } from './clients/OpenAiGptClient';
 export { VercelAiGptClient } from './clients/VercelAiGptClient';
 export { runGenerateSiteTests } from './codegen/runGenerateSiteTests';
@@ -25,9 +25,10 @@ export { DonobuFlow } from './managers/DonobuFlow';
 export { distillAllowedEnvVariableNames, DonobuFlowsManager, } from './managers/DonobuFlowsManager';
 export { type DonobuStack, setupDonobuStack } from './managers/DonobuStack';
 export { InteractionVisualizer } from './managers/InteractionVisualizer';
-export { type PluginDependencies, PluginLoader } from './managers/PluginLoader';
+export { type LoadedPlugins, type PluginDependencies, PluginLoader, } from './managers/PluginLoader';
 export type * from './managers/TargetInspector';
 export { ToolManager } from './managers/ToolManager';
+export { createDefaultToolRegistry, type ToolRegistry, } from './managers/ToolRegistry';
 export * from './managers/WebTargetInspector';
 export * from './models/BrowserStorageState';
 export * from './models/CodeGenerationOptions';
@@ -48,9 +49,9 @@ export * from './models/ToolSchema';
 export type { VideoSegment } from './models/VideoSegment';
 export type { EnvPersistence } from './persistence/env/EnvPersistence';
 export type { FlowsPersistence } from './persistence/flows/FlowsPersistence';
-export { type PersistencePlugin, registerPersistencePlugin, } from './persistence/PersistencePlugin';
+export { type PersistencePlugin, PersistencePluginRegistry, } from './persistence/PersistencePlugin';
 export type { TargetRuntime } from './targets/TargetRuntime';
-export { registerTargetRuntimePlugin, type TargetRuntimeParams, type TargetRuntimePlugin, } from './targets/TargetRuntimePlugin';
+export { type TargetRuntimeParams, type TargetRuntimePlugin, TargetRuntimePluginRegistry, } from './targets/TargetRuntimePlugin';
 export * from './tools/ReplayableInteraction';
 export * from './tools/Tool';
 export * from './utils/createTool';

package/dist/esm/main.js

@@ -14,18 +14,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerTargetRuntimePlugin = exports.registerPersistencePlugin = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.env = exports.runGenerateSiteTests = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.registerGptClientPlugin = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
+exports.TargetRuntimePluginRegistry = exports.PersistencePluginRegistry = exports.createDefaultToolRegistry = exports.ToolManager = exports.PluginLoader = exports.InteractionVisualizer = exports.setupDonobuStack = exports.DonobuFlowsManager = exports.distillAllowedEnvVariableNames = exports.DonobuFlow = exports.env = exports.runGenerateSiteTests = exports.VercelAiGptClient = exports.OpenAiGptClient = exports.GptClientPluginRegistry = exports.GptClient = exports.GoogleGenerativeAiGptClient = exports.fixAssertFields = exports.DonobuGptClient = exports.AnthropicGptClient = void 0;
 exports.startDonobuServer = startDonobuServer;
 const commander_1 = require("commander");
 const v4_1 = require("zod/v4");
 const envVars_1 = require("./envVars");
 const init_1 = require("./init");
 const AdminApiController_1 = require("./managers/AdminApiController");
-const PluginLoader_1 = require("./managers/PluginLoader");
-const ToolManager_1 = require("./managers/ToolManager");
 const ControlPanel_1 = require("./models/ControlPanel");
-const TargetRuntimePlugin_1 = require("./targets/TargetRuntimePlugin");
-const WebTargetRuntime_1 = require("./targets/WebTargetRuntime");
 const Logger_1 = require("./utils/Logger");
 const PlaywrightUtils_1 = require("./utils/PlaywrightUtils");
 var AnthropicGptClient_1 = require("./clients/AnthropicGptClient");
@@ -38,7 +34,7 @@ Object.defineProperty(exports, "GoogleGenerativeAiGptClient", { enumerable: true
 var GptClient_1 = require("./clients/GptClient");
 Object.defineProperty(exports, "GptClient", { enumerable: true, get: function () { return GptClient_1.GptClient; } });
 var GptClientPlugin_1 = require("./clients/GptClientPlugin");
-Object.defineProperty(exports, "registerGptClientPlugin", { enumerable: true, get: function () { return GptClientPlugin_1.registerGptClientPlugin; } });
+Object.defineProperty(exports, "GptClientPluginRegistry", { enumerable: true, get: function () { return GptClientPlugin_1.GptClientPluginRegistry; } });
 var OpenAiGptClient_1 = require("./clients/OpenAiGptClient");
 Object.defineProperty(exports, "OpenAiGptClient", { enumerable: true, get: function () { return OpenAiGptClient_1.OpenAiGptClient; } });
 var VercelAiGptClient_1 = require("./clients/VercelAiGptClient");
@@ -69,10 +65,12 @@ var DonobuStack_1 = require("./managers/DonobuStack");
 Object.defineProperty(exports, "setupDonobuStack", { enumerable: true, get: function () { return DonobuStack_1.setupDonobuStack; } });
 var InteractionVisualizer_1 = require("./managers/InteractionVisualizer");
 Object.defineProperty(exports, "InteractionVisualizer", { enumerable: true, get: function () { return InteractionVisualizer_1.InteractionVisualizer; } });
-var PluginLoader_2 = require("./managers/PluginLoader");
-Object.defineProperty(exports, "PluginLoader", { enumerable: true, get: function () { return PluginLoader_2.PluginLoader; } });
-var ToolManager_2 = require("./managers/ToolManager");
-Object.defineProperty(exports, "ToolManager", { enumerable: true, get: function () { return ToolManager_2.ToolManager; } });
+var PluginLoader_1 = require("./managers/PluginLoader");
+Object.defineProperty(exports, "PluginLoader", { enumerable: true, get: function () { return PluginLoader_1.PluginLoader; } });
+var ToolManager_1 = require("./managers/ToolManager");
+Object.defineProperty(exports, "ToolManager", { enumerable: true, get: function () { return ToolManager_1.ToolManager; } });
+var ToolRegistry_1 = require("./managers/ToolRegistry");
+Object.defineProperty(exports, "createDefaultToolRegistry", { enumerable: true, get: function () { return ToolRegistry_1.createDefaultToolRegistry; } });
 __exportStar(require("./managers/WebTargetInspector"), exports);
 __exportStar(require("./models/BrowserStorageState"), exports);
 __exportStar(require("./models/CodeGenerationOptions"), exports);
@@ -85,9 +83,9 @@ __exportStar(require("./models/TargetConfig"), exports);
 __exportStar(require("./models/ToolCallResult"), exports);
 __exportStar(require("./models/ToolSchema"), exports);
 var PersistencePlugin_1 = require("./persistence/PersistencePlugin");
-Object.defineProperty(exports, "registerPersistencePlugin", { enumerable: true, get: function () { return PersistencePlugin_1.registerPersistencePlugin; } });
-var TargetRuntimePlugin_2 = require("./targets/TargetRuntimePlugin");
-Object.defineProperty(exports, "registerTargetRuntimePlugin", { enumerable: true, get: function () { return TargetRuntimePlugin_2.registerTargetRuntimePlugin; } });
+Object.defineProperty(exports, "PersistencePluginRegistry", { enumerable: true, get: function () { return PersistencePlugin_1.PersistencePluginRegistry; } });
+var TargetRuntimePlugin_1 = require("./targets/TargetRuntimePlugin");
+Object.defineProperty(exports, "TargetRuntimePluginRegistry", { enumerable: true, get: function () { return TargetRuntimePlugin_1.TargetRuntimePluginRegistry; } });
 __exportStar(require("./tools/ReplayableInteraction"), exports);
 __exportStar(require("./tools/Tool"), exports);
 __exportStar(require("./utils/createTool"), exports);
@@ -104,17 +102,6 @@ const DEFAULT_PORT = 31000;
  */
 async function startDonobuServer({ port = DEFAULT_PORT, controlPanelHost = ControlPanel_1.NoOpControlPanelFactory, } = {}) {
     try {
-        // Register built-in target runtime plugins before external plugins,
-        // so that external plugins can override them if needed.
-        (0, TargetRuntimePlugin_1.registerTargetRuntimePlugin)(WebTargetRuntime_1.webTargetRuntimePlugin);
-        // Load all plugins (tools + persistence + target runtimes) in a single
-        // directory scan. Persistence plugins must be registered before
-        // setupDonobuStack() runs (which happens inside AdminApiController.create
-        // below).
-        const pluginLoader = await PluginLoader_1.PluginLoader.create();
-        const { tools } = await pluginLoader.loadAllPlugins();
-        ToolManager_1.ToolManager.setPluginTools(tools);
-        void (await ToolManager_1.ToolManager.allTools());
         const adminController = await AdminApiController_1.AdminApiController.create(envVars_1.env.data.DONOBU_DEPLOYMENT_ENVIRONMENT ?? 'LOCAL', controlPanelHost, envVars_1.env);
         adminController.start(port);
         Logger_1.appLogger.info(`Donobu API server available on http://localhost:${port}`);

package/dist/esm/managers/AdminApiController.js

@@ -233,13 +233,13 @@ class AdminApiController {
             gptConfigsApi: new GptConfigsApi_1.GptConfigsApi(donobuStack.gptConfigsManager, donobuStack.agentsManager),
             agentsApi: new AgentsApi_1.AgentsApi(donobuStack.agentsManager),
             askAiApi: new AskAiApi_1.AskAiApi(donobuStack.gptClientFactory, donobuStack.gptConfigsManager, donobuStack.agentsManager),
-            toolsApi: new ToolsApi_1.ToolsApi(),
+            toolsApi: new ToolsApi_1.ToolsApi(donobuStack.toolRegistry),
             flowsApi: new FlowsApi_1.FlowsApi(donobuStack.flowsManager),
             flowsFilesApi: new FlowsFilesApi_1.FlowsFilesApi(donobuStack.flowsPersistenceRegistry),
             flowsToolCallsApi: new FlowsToolCallsApi_1.FlowsToolCallsApi(donobuStack.flowsManager),
             pingApi: new PingApi_1.PingApi(),
             schemaApi: new SchemaApi_1.SchemaApi(),
-            targetsApi: new TargetsApi_1.TargetsApi(),
+            targetsApi: new TargetsApi_1.TargetsApi(donobuStack.targetRuntimePlugins),
         };
     }
     /**

package/dist/esm/managers/DonobuFlowsManager.d.ts

@@ -1,5 +1,6 @@
 import type { EnvPick } from 'env-struct';
 import type { BrowserContext } from 'playwright';
+import type { z } from 'zod/v4';
 import type { GptClient } from '../clients/GptClient';
 import type { GptClientFactory } from '../clients/GptClientFactory';
 import type { GeneratedProject } from '../codegen/CodeGenerator';
@@ -18,11 +19,14 @@ import type { PaginatedResult } from '../models/PaginatedResult';
 import type { ProposedToolCall } from '../models/ProposedToolCall';
 import type { ToolCall } from '../models/ToolCall';
 import type { FlowsPersistenceRegistry } from '../persistence/flows/FlowsPersistenceRegistry';
+import type { TargetRuntimePluginRegistry } from '../targets/TargetRuntimePlugin';
+import type { Tool } from '../tools/Tool';
 import type { FlowLogSnapshot } from '../utils/FlowLogBuffer';
 import type { AgentsManager } from './AgentsManager';
 import { DonobuFlow } from './DonobuFlow';
 import type { EnvDataManager } from './EnvDataManager';
 import type { GptConfigsManager } from './GptConfigsManager';
+import type { ToolRegistry } from './ToolRegistry';
 /**
  * Response wrapper for `createFlow` calls.
  */
@@ -36,14 +40,15 @@ export declare class DonobuFlowsManager {
     private readonly envDataManager;
     private readonly controlPanelFactory;
     private readonly environ;
+    private readonly toolRegistry;
+    private readonly targetRuntimePlugins;
     static readonly DEFAULT_MESSAGE_DURATION = 2247;
     static readonly DEFAULT_MAX_TOOL_CALLS = 50;
     static readonly DEFAULT_BROWSER_STATE_FILENAME = "browserstate.json";
     static readonly FLOW_NAME_MAX_LENGTH = 255;
     private readonly flowRuntime;
     private readonly flowCatalog;
-    private readonly flowDependencyResolver;
-    constructor(deploymentEnvironment: DonobuDeploymentEnvironment, gptClientFactory: GptClientFactory, gptConfigsManager: GptConfigsManager, agentsManager: AgentsManager, flowsPersistenceRegistry: FlowsPersistenceRegistry, envDataManager: EnvDataManager, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME'>);
+    constructor(deploymentEnvironment: DonobuDeploymentEnvironment, gptClientFactory: GptClientFactory, gptConfigsManager: GptConfigsManager, agentsManager: AgentsManager, flowsPersistenceRegistry: FlowsPersistenceRegistry, envDataManager: EnvDataManager, controlPanelFactory: ControlPanelFactory, environ: EnvPick<typeof env, 'ANTHROPIC_API_KEY' | 'ANTHROPIC_MODEL_NAME' | 'AWS_ACCESS_KEY_ID' | 'AWS_BEDROCK_MODEL_NAME' | 'AWS_SECRET_ACCESS_KEY' | 'BASE64_GPT_CONFIG' | 'BROWSERBASE_API_KEY' | 'BROWSERBASE_PROJECT_ID' | 'DONOBU_API_KEY' | 'GOOGLE_GENERATIVE_AI_API_KEY' | 'GOOGLE_GENERATIVE_AI_MODEL_NAME' | 'OPENAI_API_KEY' | 'OPENAI_API_MODEL_NAME'>, toolRegistry: ToolRegistry, targetRuntimePlugins: TargetRuntimePluginRegistry);
     /**
      * Create a flow with the given parameters and invoke its `DonobuFlow#run`
      * method, adding it to list of active flows.
@@ -166,6 +171,21 @@ export declare class DonobuFlowsManager {
  * );
  */
 export declare function distillAllowedEnvVariableNames(overallObjective: string | null | undefined, explicitlyAllowedEnvVariableNames: string[] | null | undefined): string[];
+/**
+ * Resolves the final set of tools a flow is permitted to use.
+ *
+ * The resolution follows this priority:
+ * 1. If the caller explicitly listed tools, use those (filtered to the target).
+ * 2. Otherwise, fall back to target-appropriate defaults (curated subset for
+ *    web, all target-compatible tools for plugin-provided targets).
+ * 3. Tools required by `toolCallsOnStart` are always included.
+ * 4. Custom (user-defined) tools are prepended.
+ * 5. GPT-requiring tools are stripped when no GPT client is available.
+ * 6. Minimal tools (objective bookkeeping) are guaranteed present.
+ * 7. The result is deduplicated and sorted by name.
+ */
+/** @internal Exported for testing. */
+export declare function setupAllowedTools(flowParams: Pick<CreateDonobuFlow, 'customTools' | 'toolCallsOnStart' | 'allowedTools'>, hasGptClient: boolean, targetType: string, toolRegistry: ToolRegistry): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
 /**
  * Convert an *executed* list of {@link ToolCall}s into a list of
  * {@link ProposedToolCall}s that can be replayed in a fresh browser

package/dist/esm/managers/DonobuFlowsManager.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DonobuFlowsManager = void 0;
 exports.distillAllowedEnvVariableNames = distillAllowedEnvVariableNames;
+exports.setupAllowedTools = setupAllowedTools;
 exports.prepareToolCallsForRerun = prepareToolCallsForRerun;
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs/promises"));
@@ -50,7 +51,6 @@ const ToolRequiresGptException_1 = require("../exceptions/ToolRequiresGptExcepti
 const UnknownToolException_1 = require("../exceptions/UnknownToolException");
 const GptConfig_1 = require("../models/GptConfig");
 const resolveTargetRuntime_1 = require("../targets/resolveTargetRuntime");
-const TargetRuntimePlugin_1 = require("../targets/TargetRuntimePlugin");
 const ChooseSelectOptionTool_1 = require("../tools/ChooseSelectOptionTool");
 const ClickTool_1 = require("../tools/ClickTool");
 const CustomToolRunnerTool_1 = require("../tools/CustomToolRunnerTool");
@@ -69,12 +69,11 @@ const MiscUtils_1 = require("../utils/MiscUtils");
 const TemplateInterpolator_1 = require("../utils/TemplateInterpolator");
 const DonobuFlow_1 = require("./DonobuFlow");
 const FlowCatalog_1 = require("./FlowCatalog");
-const FlowDependencyResolver_1 = require("./FlowDependencyResolver");
 const FlowRuntime_1 = require("./FlowRuntime");
 const InteractionVisualizer_1 = require("./InteractionVisualizer");
 const ToolManager_1 = require("./ToolManager");
 class DonobuFlowsManager {
-    constructor(deploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ) {
+    constructor(deploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, toolRegistry, targetRuntimePlugins) {
         this.deploymentEnvironment = deploymentEnvironment;
         this.gptClientFactory = gptClientFactory;
         this.gptConfigsManager = gptConfigsManager;
@@ -83,9 +82,10 @@ class DonobuFlowsManager {
         this.envDataManager = envDataManager;
         this.controlPanelFactory = controlPanelFactory;
         this.environ = environ;
+        this.toolRegistry = toolRegistry;
+        this.targetRuntimePlugins = targetRuntimePlugins;
         this.flowRuntime = new FlowRuntime_1.FlowRuntime();
         this.flowCatalog = new FlowCatalog_1.FlowCatalog(this.flowsPersistenceRegistry, this.flowRuntime, this.deploymentEnvironment);
-        this.flowDependencyResolver = new FlowDependencyResolver_1.FlowDependencyResolver(this.flowCatalog);
     }
     /**
      * Create a flow with the given parameters and invoke its `DonobuFlow#run`
@@ -124,7 +124,7 @@ class DonobuFlowsManager {
             const initialRunMode = flowParams.initialRunMode ??
                 (gptClientData.gptClient ? 'AUTONOMOUS' : 'INSTRUCT');
             // --- Generic validation (target-agnostic) ---
-            await validateFlowParams(flowParams, gptClientData.gptClient, initialRunMode);
+            await validateFlowParams(flowParams, gptClientData.gptClient, initialRunMode, this.toolRegistry);
             const messageDuration = flowParams.defaultMessageDuration ??
                 DonobuFlowsManager.DEFAULT_MESSAGE_DURATION;
             const interactionVisualizer = new InteractionVisualizer_1.InteractionVisualizer(messageDuration);
@@ -137,9 +137,9 @@ class DonobuFlowsManager {
                 environ: this.environ,
                 browserContextOverride,
                 getBrowserStorageState: (ref) => this.getBrowserStorageState(ref),
-            });
+            }, this.targetRuntimePlugins);
             try {
-                const allowedTools = await setupAllowedTools(flowParams, gptClientData !== null, targetRuntime.targetType);
+                const allowedTools = await setupAllowedTools(flowParams, gptClientData !== null, targetRuntime.targetType, this.toolRegistry);
                 const toolManager = new ToolManager_1.ToolManager(allowedTools);
                 const toolCallsOnStart = flowParams.toolCallsOnStart?.length
                     ? flowParams.toolCallsOnStart
@@ -285,7 +285,7 @@ class DonobuFlowsManager {
         const originalToolCalls = await this.getToolCalls(flowId);
         // Delegate tool call preparation to the target runtime plugin so that
         // rerun logic is fully target-agnostic.
-        const plugin = (0, TargetRuntimePlugin_1.getTargetRuntimePlugin)(priorFlowMetadata.target);
+        const plugin = this.targetRuntimePlugins.get(priorFlowMetadata.target);
         const toolCallsOnStart = plugin
             ? await plugin.prepareToolCallsForRerun(originalToolCalls, options)
             : await prepareToolCallsForRerun(originalToolCalls, options);
@@ -323,7 +323,7 @@ class DonobuFlowsManager {
         if (!activeFlowHandle) {
             throw new ActiveFlowNotFoundException_1.ActiveFlowNotFoundException(flowId);
         }
-        const tool = (await ToolManager_1.ToolManager.allTools()).find((t) => t.name === toolName);
+        const tool = this.toolRegistry.allTools().find((t) => t.name === toolName);
         if (!tool) {
             throw new UnknownToolException_1.UnknownToolException(toolName);
         }
@@ -425,9 +425,9 @@ class DonobuFlowsManager {
         const proposedToolCalls = await prepareToolCallsForRerun(originalToolCalls, effectiveOptions);
         const scriptVariant = effectiveOptions.playwrightScriptVariant === 'classic' ? 'classic' : 'ai';
         if (scriptVariant === 'classic') {
-            return (0, CodeGenerator_1.getFlowAsPlaywrightScript)(flowMetadata, proposedToolCalls, effectiveOptions);
+            return (0, CodeGenerator_1.getFlowAsPlaywrightScript)(flowMetadata, proposedToolCalls, effectiveOptions, this.toolRegistry);
         }
-        return (0, CodeGenerator_1.getFlowAsAiPlaywrightScript)(flowMetadata, proposedToolCalls, effectiveOptions);
+        return (0, CodeGenerator_1.getFlowAsAiPlaywrightScript)(flowMetadata, proposedToolCalls, effectiveOptions, this.toolRegistry);
     }
     /**
      * Generates a complete Playwright project structure for multiple flows with dependency management.
@@ -473,7 +473,7 @@ class DonobuFlowsManager {
         catch (error) {
             Logger_1.appLogger.warn('Error while resolving default GPT client configuration when generating project code', error);
         }
-        return await (0, CodeGenerator_1.generateProject)(flowsWithToolCalls, resolvedBrowserStates, defaultGptConfig, options);
+        return await (0, CodeGenerator_1.generateProject)(flowsWithToolCalls, resolvedBrowserStates, defaultGptConfig, options, this.toolRegistry);
     }
     /**
      * Resolves a GPT client using the provided GPT configuration name, falling back
@@ -664,7 +664,7 @@ function validateFlowName(flowName) {
         throw new InvalidParamValueException_1.InvalidParamValueException('name', flowName, `the value cannot be longer than ${DonobuFlowsManager.FLOW_NAME_MAX_LENGTH} characters`);
     }
 }
-async function validateFlowParams(flowParams, gptClient, initialRunMode) {
+async function validateFlowParams(flowParams, gptClient, initialRunMode, toolRegistry) {
     // Target-specific validation (e.g. targetWebsite URL format) is handled
     // by the TargetRuntimePlugin.validate() call in resolveTargetRuntime().
     // This function only validates target-agnostic parameters.
@@ -695,13 +695,27 @@ async function validateFlowParams(flowParams, gptClient, initialRunMode) {
             throw new InvalidParamValueException_1.InvalidParamValueException('initialRunMode', initialRunMode);
     }
     if (!gptClient) {
-        await throwIfAnyToolsRequireGpt(flowParams.allowedTools ?? null, flowParams.toolCallsOnStart ?? null);
+        await throwIfAnyToolsRequireGpt(flowParams.allowedTools ?? null, flowParams.toolCallsOnStart ?? null, toolRegistry);
     }
 }
-async function setupAllowedTools(flowParams, hasGptClient, targetType) {
+/**
+ * Resolves the final set of tools a flow is permitted to use.
+ *
+ * The resolution follows this priority:
+ * 1. If the caller explicitly listed tools, use those (filtered to the target).
+ * 2. Otherwise, fall back to target-appropriate defaults (curated subset for
+ *    web, all target-compatible tools for plugin-provided targets).
+ * 3. Tools required by `toolCallsOnStart` are always included.
+ * 4. Custom (user-defined) tools are prepended.
+ * 5. GPT-requiring tools are stripped when no GPT client is available.
+ * 6. Minimal tools (objective bookkeeping) are guaranteed present.
+ * 7. The result is deduplicated and sorted by name.
+ */
+/** @internal Exported for testing. */
+async function setupAllowedTools(flowParams, hasGptClient, targetType, toolRegistry) {
     const customTools = flowParams.customTools?.map((tool) => new CustomToolRunnerTool_1.CustomToolRunnerTool(tool)) ?? [];
     const toolsNeededOnStart = flowParams.toolCallsOnStart?.map((t) => t.name) ?? [];
-    const targetCompatibleTools = await ToolManager_1.ToolManager.toolsForTarget(targetType);
+    const targetCompatibleTools = toolRegistry.toolsForTarget(targetType);
     let prepackagedTools;
     if (flowParams.allowedTools?.length) {
         const allowedTools = [...toolsNeededOnStart, ...flowParams.allowedTools];
@@ -714,7 +728,7 @@ async function setupAllowedTools(flowParams, hasGptClient, targetType) {
         // Web uses a curated default subset; other targets (provided by plugins)
         // default to all target-compatible tools.
         const defaultTools = targetType === 'web'
-            ? await ToolManager_1.ToolManager.defaultTools()
+            ? toolRegistry.defaultTools()
             : targetCompatibleTools;
         const allowedTools = [
             ...toolsNeededOnStart,
@@ -726,7 +740,7 @@ async function setupAllowedTools(flowParams, hasGptClient, targetType) {
     const prepackagedToolsWithGptFiltered = prepackagedTools.filter((tool) => {
         return hasGptClient || !tool.requiresGpt;
     });
-    const minimalTools = await ToolManager_1.ToolManager.minimalTools();
+    const minimalTools = toolRegistry.minimalTools();
     const existingToolNames = new Set([...customTools, ...prepackagedToolsWithGptFiltered].map((tool) => tool.name));
     const missingMinimalTools = minimalTools.filter((tool) => !existingToolNames.has(tool.name));
     const combinedTools = [
@@ -775,8 +789,8 @@ async function setFlowVideo(flowId, flowTempDir, flowsPersistence) {
         await flowsPersistence.setVideo(flowId, videoBytes);
     }
 }
-async function throwIfAnyToolsRequireGpt(requestedTools, toolCallsOnStart) {
-    const toolMap = new Map((await ToolManager_1.ToolManager.allTools()).map((tool) => [tool.name, tool]));
+async function throwIfAnyToolsRequireGpt(requestedTools, toolCallsOnStart, toolRegistry) {
+    const toolMap = new Map(toolRegistry.allTools().map((tool) => [tool.name, tool]));
     const requestedToolsRequiringGpt = [...(requestedTools ?? [])].filter((name) => toolMap.get(name)?.requiresGpt);
     if (requestedToolsRequiringGpt.length) {
         throw new ToolRequiresGptException_1.ToolRequiresGptException(requestedToolsRequiringGpt[0]);