donobu 5.17.2 → 5.18.0

package/dist/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/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]);

package/dist/managers/DonobuStack.d.ts

@@ -5,11 +5,15 @@ import type { AgentsPersistence } from '../persistence/agents/AgentsPersistence'
 import type { EnvPersistenceVolatile } from '../persistence/env/EnvPersistenceVolatile';
 import { type FlowsPersistenceRegistry } from '../persistence/flows/FlowsPersistenceRegistry';
 import type { GptConfigsPersistence } from '../persistence/gptconfigs/GptConfigsPersistence';
+import { TargetRuntimePluginRegistry } from '../targets/TargetRuntimePlugin';
 import { AgentsManager } from './AgentsManager';
 import { DonobuFlowsManager } from './DonobuFlowsManager';
 import { EnvDataManager } from './EnvDataManager';
 import { GptConfigsManager } from './GptConfigsManager';
+import type { ToolRegistry } from './ToolRegistry';
 export type DonobuStack = {
+    toolRegistry: ToolRegistry;
+    targetRuntimePlugins: TargetRuntimePluginRegistry;
     gptClientFactory: GptClientFactory;
     gptConfigsPersistence: GptConfigsPersistence;
     gptConfigsManager: GptConfigsManager;

package/dist/managers/DonobuStack.js

@@ -2,16 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupDonobuStack = setupDonobuStack;
 const GptClientFactory_1 = require("../clients/GptClientFactory");
+const GptClientPlugin_1 = require("../clients/GptClientPlugin");
 const envVars_1 = require("../envVars");
 const AgentsPersistenceSqlite_1 = require("../persistence/agents/AgentsPersistenceSqlite");
 const DonobuSqliteDb_1 = require("../persistence/DonobuSqliteDb");
 const EnvPersistenceRegistry_1 = require("../persistence/env/EnvPersistenceRegistry");
 const FlowsPersistenceRegistry_1 = require("../persistence/flows/FlowsPersistenceRegistry");
 const GptConfigsPersistenceSqlite_1 = require("../persistence/gptconfigs/GptConfigsPersistenceSqlite");
+const PersistencePlugin_1 = require("../persistence/PersistencePlugin");
+const TargetRuntimePlugin_1 = require("../targets/TargetRuntimePlugin");
+const WebTargetRuntime_1 = require("../targets/WebTargetRuntime");
 const AgentsManager_1 = require("./AgentsManager");
 const DonobuFlowsManager_1 = require("./DonobuFlowsManager");
 const EnvDataManager_1 = require("./EnvDataManager");
 const GptConfigsManager_1 = require("./GptConfigsManager");
+const PluginLoader_1 = require("./PluginLoader");
+const ToolRegistry_1 = require("./ToolRegistry");
 /**
  * Create a new Donobu application stack.
  *
@@ -24,17 +30,24 @@ const GptConfigsManager_1 = require("./GptConfigsManager");
  *       environment variables.
  */
 async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory, envPersistenceVolatile, environ = envVars_1.env.pick('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_BASE_URL', 'DONOBU_API_KEY', 'GOOGLE_GENERATIVE_AI_API_KEY', 'GOOGLE_GENERATIVE_AI_MODEL_NAME', 'OPENAI_API_KEY', 'OPENAI_API_MODEL_NAME', 'PERSISTENCE_PRIORITY')) {
-    const gptClientFactory = new GptClientFactory_1.GptClientFactoryImpl();
+    const loadedPlugins = await loadDefaultPlugins();
+    const resolvedToolRegistry = await (0, ToolRegistry_1.createDefaultToolRegistry)(loadedPlugins.tools);
+    const persistencePlugins = new PersistencePlugin_1.PersistencePluginRegistry(loadedPlugins.persistencePlugins);
+    const gptClientPlugins = new GptClientPlugin_1.GptClientPluginRegistry(loadedPlugins.gptClientPlugins);
+    const targetRuntimePlugins = new TargetRuntimePlugin_1.TargetRuntimePluginRegistry(loadedPlugins.targetRuntimePlugins);
+    const gptClientFactory = new GptClientFactory_1.GptClientFactoryImpl(gptClientPlugins);
     const sqliteDb = await (0, DonobuSqliteDb_1.getDonobuSqliteDatabase)();
     const gptConfigsPersistence = await GptConfigsPersistenceSqlite_1.GptConfigsPersistenceSqlite.create(sqliteDb);
     const gptConfigsManager = await GptConfigsManager_1.GptConfigsManager.create(gptConfigsPersistence, gptClientFactory);
     const agentsPersistence = await AgentsPersistenceSqlite_1.AgentsPersistenceSqlite.create(sqliteDb);
     const agentsManager = await AgentsManager_1.AgentsManager.create(agentsPersistence, gptConfigsManager);
-    const flowsPersistenceRegistry = await FlowsPersistenceRegistry_1.FlowsPersistenceRegistryImpl.fromEnvironment(environ);
-    const envPersistenceFactory = await EnvPersistenceRegistry_1.EnvPersistenceRegistryImpl.fromEnvironment(envPersistenceVolatile ?? null, environ);
+    const flowsPersistenceRegistry = await FlowsPersistenceRegistry_1.FlowsPersistenceRegistryImpl.fromEnvironment(environ, persistencePlugins);
+    const envPersistenceFactory = await EnvPersistenceRegistry_1.EnvPersistenceRegistryImpl.fromEnvironment(envPersistenceVolatile ?? null, environ, persistencePlugins);
     const envDataManager = new EnvDataManager_1.EnvDataManager(envPersistenceFactory);
-    const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ);
+    const flowsManager = new DonobuFlowsManager_1.DonobuFlowsManager(donobuDeploymentEnvironment, gptClientFactory, gptConfigsManager, agentsManager, flowsPersistenceRegistry, envDataManager, controlPanelFactory, environ, resolvedToolRegistry, targetRuntimePlugins);
     return {
+        toolRegistry: resolvedToolRegistry,
+        targetRuntimePlugins,
         gptClientFactory,
         gptConfigsPersistence,
         gptConfigsManager,
@@ -45,4 +58,14 @@ async function setupDonobuStack(donobuDeploymentEnvironment, controlPanelFactory
         envDataManager,
     };
 }
+/**
+ * Discover and load all plugins from disk, prepending the built-in web
+ * target runtime so it's always available.
+ */
+async function loadDefaultPlugins() {
+    const pluginLoader = await PluginLoader_1.PluginLoader.create();
+    const plugins = await pluginLoader.loadAllPlugins();
+    plugins.targetRuntimePlugins.unshift(WebTargetRuntime_1.webTargetRuntimePlugin);
+    return plugins;
+}
 //# sourceMappingURL=DonobuStack.js.map

package/dist/managers/PluginLoader.d.ts

@@ -1,7 +1,17 @@
 import * as playwright from 'playwright';
 import type sharp from 'sharp';
 import type { z } from 'zod/v4';
+import type { GptClientPlugin } from '../clients/GptClientPlugin';
+import type { PersistencePlugin } from '../persistence/PersistencePlugin';
+import type { TargetRuntimePlugin } from '../targets/TargetRuntimePlugin';
 import type { Tool } from '../tools/Tool';
+/** The result of loading all plugins — no global state, just data. */
+export type LoadedPlugins = {
+    tools: Tool<z.ZodObject, z.ZodObject>[];
+    persistencePlugins: Map<string, PersistencePlugin>;
+    gptClientPlugins: GptClientPlugin[];
+    targetRuntimePlugins: TargetRuntimePlugin[];
+};
 export type PluginDependencies = {
     donobu: typeof import('../main');
     playwright: typeof playwright;
@@ -41,12 +51,9 @@ export declare class PluginLoader {
     static create(pluginsPath?: string, pluginDependencies?: PluginDependencies): Promise<PluginLoader>;
     /**
      * Discovers and loads all plugins from both the app-data directory and
-     * `node_modules`. Tool plugins are collected and returned; other plugin
-     * types (persistence, GPT client, target runtime) are registered globally.
+     * `node_modules`. All plugin types are collected and returned.
      */
-    loadAllPlugins(): Promise<{
-        tools: Tool<z.ZodObject, z.ZodObject>[];
-    }>;
+    loadAllPlugins(): Promise<LoadedPlugins>;
     /**
      * Scan the app-data plugins directory for standalone plugin bundles.
      * Each plugin is a directory containing an `index.mjs` entry point.

package/dist/managers/PluginLoader.js

@@ -41,9 +41,6 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_url_1 = require("node:url");
 const playwright = __importStar(require("playwright"));
-const GptClientPlugin_1 = require("../clients/GptClientPlugin");
-const PersistencePlugin_1 = require("../persistence/PersistencePlugin");
-const TargetRuntimePlugin_1 = require("../targets/TargetRuntimePlugin");
 const Logger_1 = require("../utils/Logger");
 const MiscUtils_1 = require("../utils/MiscUtils");
 async function getDefaultDependencies() {
@@ -114,8 +111,7 @@ class PluginLoader {
     }
     /**
      * Discovers and loads all plugins from both the app-data directory and
-     * `node_modules`. Tool plugins are collected and returned; other plugin
-     * types (persistence, GPT client, target runtime) are registered globally.
+     * `node_modules`. All plugin types are collected and returned.
      */
     async loadAllPlugins() {
         const dirPlugins = await this.discoverDirectoryPlugins();
@@ -130,6 +126,9 @@ class PluginLoader {
             }
         }
         const tools = [];
+        const persistencePlugins = new Map();
+        const gptClientPlugins = [];
+        const targetRuntimePlugins = [];
         for (const plugin of allPlugins) {
             Logger_1.appLogger.info(`↳ Loading plugin "${plugin.name}" from ${plugin.entryPoint}`);
             try {
@@ -151,8 +150,8 @@ class PluginLoader {
                     'function') {
                     const result = await mod.loadPersistencePlugin(this.pluginDependencies);
                     if (result) {
-                        (0, PersistencePlugin_1.registerPersistencePlugin)(result.key, result.plugin);
-                        Logger_1.appLogger.info(`  ✔ Registered persistence plugin "${result.key}" from "${plugin.name}".`);
+                        persistencePlugins.set(result.key, result.plugin);
+                        Logger_1.appLogger.info(`  ✔ Loaded persistence plugin "${result.key}" from "${plugin.name}".`);
                     }
                 }
                 // GPT client plugins
@@ -160,8 +159,8 @@ class PluginLoader {
                     'function') {
                     const gptPlugins = await mod.loadGptClientPlugins(this.pluginDependencies);
                     for (const gptPlugin of gptPlugins) {
-                        (0, GptClientPlugin_1.registerGptClientPlugin)(gptPlugin);
-                        Logger_1.appLogger.info(`  ✔ Registered GPT client plugin "${gptPlugin.type}" from "${plugin.name}".`);
+                        gptClientPlugins.push(gptPlugin);
+                        Logger_1.appLogger.info(`  ✔ Loaded GPT client plugin "${gptPlugin.type}" from "${plugin.name}".`);
                     }
                 }
                 // Target runtime plugins
@@ -170,8 +169,8 @@ class PluginLoader {
                     const targetPlugins = await mod
                         .loadTargetRuntimePlugins(this.pluginDependencies);
                     for (const targetPlugin of targetPlugins) {
-                        (0, TargetRuntimePlugin_1.registerTargetRuntimePlugin)(targetPlugin);
-                        Logger_1.appLogger.info(`  ✔ Registered target runtime plugin "${targetPlugin.type}" from "${plugin.name}".`);
+                        targetRuntimePlugins.push(targetPlugin);
+                        Logger_1.appLogger.info(`  ✔ Loaded target runtime plugin "${targetPlugin.type}" from "${plugin.name}".`);
                     }
                 }
             }
@@ -181,7 +180,12 @@ class PluginLoader {
             }
         }
         Logger_1.appLogger.info(`Loaded ${tools.length} custom tool(s) from plugins.`);
-        return { tools };
+        return {
+            tools,
+            persistencePlugins,
+            gptClientPlugins,
+            targetRuntimePlugins,
+        };
     }
     // ---------------------------------------------------------------------------
     // Discovery: app-data plugins directory

package/dist/managers/ToolManager.d.ts

@@ -4,33 +4,14 @@ import type { ToolCallContext } from '../models/ToolCallContext';
 import type { ToolTemplateDataSource } from '../models/ToolTemplateDataSource';
 import type { Tool } from '../tools/Tool';
 /**
- * Manages calls to a given list of tools.
+ * Executes tool calls against a given list of tools.
+ *
+ * Construct with the specific tool set a flow is allowed to use. Tool
+ * *discovery* (which tools exist, defaults, plugins) is handled by
+ * {@link ToolRegistry} — this class only cares about *execution*.
  */
 export declare class ToolManager {
     readonly tools: Tool<z.ZodObject, z.ZodObject>[];
-    private static PLUGIN_TOOLS;
-    private static MINIMAL_TOOLS;
-    private static ALL_TOOLS;
-    private static PREPACKAGED_TOOLS;
-    private static DEFAULT_TOOLS;
-    private static pluginLoader;
-    /**
-     * Pre-populate the plugin tools cache. When called before
-     * {@link pluginTools}, this avoids a redundant directory scan.
-     */
-    static setPluginTools(tools: Tool<z.ZodObject, z.ZodObject>[]): void;
-    static pluginTools(): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
-    static minimalTools(): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
-    static prepackagedTools(): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
-    static defaultTools(): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
-    /**
-     * Returns all tools compatible with the given target type.
-     *
-     * A tool is compatible if its `supportedTargets` array is empty
-     * (target-agnostic) or contains the given `targetType`.
-     */
-    static toolsForTarget(targetType: string): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
-    static allTools(): Promise<Tool<z.ZodObject, z.ZodObject>[]>;
     constructor(tools: Tool<z.ZodObject, z.ZodObject>[]);
     /**
      * Invokes a tool by name with the provided parameters.
@@ -50,14 +31,14 @@ export declare class ToolManager {
      * @returns A Promise resolving to a ToolCall object containing execution details and results
      */
     invokeTool(context: ToolCallContext, toolName: string, toolParameters: Record<string, any>, isFromGpt: boolean): Promise<ToolCall>;
-    /**
-     * Builds a data source for interpolation for that includes the interpolated parameters
-     * of previous tool calls. This method assumes the first tool call in the given history
-     * requires no interpolation, and then works its way through the history so that each
-     * subsequent tool call can be interpolated with the results of the previous ones.
-     *
-     * Public for testing purposes only.
-     */
-    static buildDataSourceForInterpolation(envData: Record<string, string>, previousToolCalls: ToolCall[]): ToolTemplateDataSource;
 }
+/**
+ * Builds a data source for template interpolation that includes the
+ * interpolated parameters of previous tool calls.
+ *
+ * The first tool call in the given history is assumed to require no
+ * interpolation; each subsequent call can reference the results of the
+ * ones before it via `{{$.calls[n].result}}` syntax.
+ */
+export declare function buildToolInterpolationDataSource(envData: Record<string, string>, previousToolCalls: ToolCall[]): ToolTemplateDataSource;
 //# sourceMappingURL=ToolManager.d.ts.map