donobu 2.48.1 → 2.49.0

package/dist/esm/managers/DonobuFlowsManager.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DonobuFlowsManager = void 0;
+exports.distillAllowedEnvVariableNames = distillAllowedEnvVariableNames;
 const BrowserUtils_1 = require("../utils/BrowserUtils");
 const DonobuFlow_1 = require("./DonobuFlow");
 const GoToWebpageTool_1 = require("../tools/GoToWebpageTool");
@@ -46,7 +47,7 @@ const UnknownToolException_1 = require("../exceptions/UnknownToolException");
 const CannotDeleteRunningFlowException_1 = require("../exceptions/CannotDeleteRunningFlowException");
 const FlowNotFoundException_1 = require("../exceptions/FlowNotFoundException");
 const ToolRequiresGptException_1 = require("../exceptions/ToolRequiresGptException");
-const fs = __importStar(require("fs"));
+const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
 const os_1 = require("os");
 const BrowserStateNotFoundException_1 = require("../exceptions/BrowserStateNotFoundException");
@@ -94,19 +95,19 @@ class DonobuFlowsManager {
                 : await this.createGptClient(flowParams.gptConfigNameOverride ?? null);
             const initialRunMode = flowParams.initialRunMode ??
                 (gptClientData.gptClient ? 'AUTONOMOUS' : 'INSTRUCT');
-            const browserConfig = flowParams.browser ?? this.getDefaultBrowserConfig();
+            const browserConfig = flowParams.browser ?? getDefaultBrowserConfig(this.environ);
             if (browserConfig.using.type === 'device' &&
                 !BrowserUtils_1.BrowserUtils.getSupportedDevices().has(browserConfig.using.deviceName ?? '')) {
                 throw new InvalidParamValueException_1.InvalidParamValueException('deviceName', browserConfig.using.deviceName);
             }
-            await this.validateFlowParams(flowParams, gptClientData.gptClient, initialRunMode);
+            await validateFlowParams(flowParams, gptClientData.gptClient, initialRunMode);
             const isControlPanelEnabled = !(browserConfig.using.type === 'device'
                 ? browserConfig.using.headless
                 : false) &&
                 (flowParams.isControlPanelEnabled ?? true);
-            const allowedTools = await this.setupAllowedTools(flowParams, gptClientData !== null);
+            const allowedTools = await setupAllowedTools(flowParams, gptClientData !== null);
             const toolManager = new ToolManager_1.ToolManager(allowedTools);
-            const toolCallsOnStart = this.prepareInitialToolCalls(flowParams);
+            const toolCallsOnStart = prepareInitialToolCalls(flowParams);
             const messageDuration = flowParams.defaultMessageDuration ??
                 DonobuFlowsManager.DEFAULT_MESSAGE_DURATION;
             const interactionVisualizer = new InteractionVisualizer_1.InteractionVisualizer(messageDuration);
@@ -119,7 +120,7 @@ class DonobuFlowsManager {
             if (maxToolCalls !== null && maxToolCalls < 0) {
                 throw new InvalidParamValueException_1.InvalidParamValueException('maxToolCalls', String(flowParams.maxToolCalls));
             }
-            const allowedEnvVarsByName = DonobuFlowsManager.distillAllowedEnvVariableNames(flowParams.overallObjective, flowParams.envVars);
+            const allowedEnvVarsByName = distillAllowedEnvVariableNames(flowParams.overallObjective, flowParams.envVars);
             const flowMetadata = {
                 id: flowId,
                 createdWithDonobuVersion: MiscUtils_1.MiscUtils.DONOBU_VERSION,
@@ -149,7 +150,7 @@ class DonobuFlowsManager {
             };
             const tempVideoDir = flowMetadata.videoDisabled
                 ? undefined
-                : this.createTempDirectoryForFlow(flowMetadata.id);
+                : await createTempDirectoryForFlow(flowMetadata.id);
             try {
                 const flowsPersistence = await this.flowsPersistenceFactory.createPersistenceLayer();
                 const envData = await this.buildEnvData(flowMetadata.envVars ?? []);
@@ -189,12 +190,12 @@ class DonobuFlowsManager {
                         }
                         if (tempVideoDir) {
                             try {
-                                await this.setFlowVideo(donobuFlow.metadata.id, tempVideoDir, flowsPersistence);
+                                await setFlowVideo(donobuFlow.metadata.id, tempVideoDir, flowsPersistence);
                             }
                             catch (error) {
                                 Logger_1.appLogger.error('Failed to save flow video:', error);
                             }
-                            this.removeTempDirectoryForFlow(donobuFlow.metadata.id);
+                            await removeTempDirectoryForFlow(donobuFlow.metadata.id);
                         }
                     });
                     return flowHandle;
@@ -205,13 +206,13 @@ class DonobuFlowsManager {
                 }
             }
             catch (error) {
-                this.removeTempDirectoryForFlow(flowMetadata.id);
+                await removeTempDirectoryForFlow(flowMetadata.id);
                 throw error;
             }
         });
     }
     async renameFlow(flowId, name) {
-        this.validateFlowName(name);
+        validateFlowName(name);
         const activeFlowHandle = this.isLocallyRunning()
             ? this.activeFlows.get(flowId)
             : null;
@@ -304,7 +305,7 @@ class DonobuFlowsManager {
      */
     async getFlows(query) {
         // Parse the composite page token or create initial state.
-        const paginationState = this.parseCompositePageToken(query.pageToken);
+        const paginationState = parseCompositePageToken(query.pageToken);
         const requestedLimit = Math.min(Math.max(1, query.limit || 100), 100);
         // Results container.
         const combinedResults = [];
@@ -364,7 +365,7 @@ class DonobuFlowsManager {
         return {
             items: cleanResults,
             nextPageToken: hasMore
-                ? this.createCompositePageToken(paginationState)
+                ? createCompositePageToken(paginationState)
                 : undefined,
         };
     }
@@ -666,257 +667,48 @@ class DonobuFlowsManager {
         return result;
     }
     /**
-     * Returns a browser config that points to BrowserBase if the
-     * BROWSERBASE_PROJECT_ID and BROWSERBASE_API_KEY environment variables are
-     * present, otherwise, returns back a basic config that uses local Chromium.
-     */
-    getDefaultBrowserConfig() {
-        const browserBaseProjectId = this.environ.data.BROWSERBASE_PROJECT_ID;
-        if (browserBaseProjectId && this.environ.data.BROWSERBASE_API_KEY) {
-            return {
-                initialState: undefined,
-                persistState: false,
-                using: {
-                    type: 'browserBase',
-                    sessionArgs: {
-                        projectId: browserBaseProjectId,
-                        browserSettings: {
-                            advancedStealth: false, // Advanced Stealth is only available on BrowserBase enterprise plans.
-                        },
-                        keepAlive: false,
-                        proxies: false,
-                    },
-                },
-            };
-        }
-        else {
-            return {
-                initialState: undefined,
-                persistState: false,
-                using: {
-                    type: 'device',
-                    deviceName: 'Desktop Chromium',
-                    headless: false,
-                },
-            };
-        }
-    }
-    /**
-     * Extracts environment variable names from the given objective and combines
-     * it with the given explicitly allowed variables.
-     *
-     * This function performs two operations:
-     * 1. Extracts environment variable references (in the form `$.env.VARIABLE_NAME`) from the overall objective.
-     * 2. Combines these with any explicitly allowed environment variable names.
-     *
-     * The resulting array contains unique environment variable names without duplicates.
-     *
-     * @param overallObjective - The objective text that may contain environment variable references.
-     * @param explicitlyAllowedEnvVariableNames - Additional environment variable names explicitly allowed.
-     * @returns An array of unique environment variable names that are allowed to be accessed.
-     *
-     * @example
-     * // Returns ["API_KEY", "USER_NAME", "DEBUG_MODE"]
-     * distillAllowedEnvVariableNames(
-     *   "Use {{$.env.API_KEY}} to authenticate and greet {{$.env.USER_NAME}}",
-     *   ["API_KEY", "DEBUG_MODE"]
-     * );
+     * Extracts dependencies for a single flow by analyzing its browser.initialState
      */
-    static distillAllowedEnvVariableNames(overallObjective, explicitlyAllowedEnvVariableNames) {
-        let allowedEnvVarsByName = overallObjective
-            ? (0, TemplateInterpolator_1.extractInterpolationExpressions)(overallObjective)
-                .filter((exp) => {
-                return exp.startsWith('$.env.');
-            })
-                .map((exp) => {
-                return exp.substring('$.env.'.length);
-            })
-            : [];
-        // Concatonate that with the explicitly requested environment variables.
-        allowedEnvVarsByName = Array.from(new Set(allowedEnvVarsByName.concat(explicitlyAllowedEnvVariableNames ?? [])));
-        return allowedEnvVarsByName;
-    }
-    validateFlowName(flowName) {
-        if (flowName && flowName.length > 255) {
-            throw new InvalidParamValueException_1.InvalidParamValueException('name', flowName, 'the value cannot be longer than 255 characters');
-        }
-    }
-    async validateFlowParams(flowParams, gptClient, initialRunMode) {
-        const validTargetWebsiteProtocols = ['https:', 'http:'];
-        const validCallbackUrlProtocols = ['https:', 'http:'];
-        const parsedTargetWebsite = DonobuFlowsManager.parseUrl(flowParams.targetWebsite);
-        const parsedCallbackUrl = DonobuFlowsManager.parseUrl(flowParams.callbackUrl);
-        if (parsedTargetWebsite &&
-            !validTargetWebsiteProtocols.some((protocol) => protocol === parsedTargetWebsite.protocol)) {
-            throw new InvalidParamValueException_1.InvalidParamValueException('targetWebsite', flowParams.targetWebsite, 'the URL must start with a supported protocol (example: "https://")');
-        }
-        else if (flowParams.targetWebsite && !parsedTargetWebsite) {
-            throw new InvalidParamValueException_1.InvalidParamValueException('targetWebsite', flowParams.targetWebsite, 'the URL is malformed');
-        }
-        if (parsedCallbackUrl &&
-            !validCallbackUrlProtocols.some((protocol) => protocol === parsedCallbackUrl.protocol)) {
-            throw new InvalidParamValueException_1.InvalidParamValueException('callbackUrl', flowParams.callbackUrl, 'the URL must start with a supported protocol (example: "https://")');
-        }
-        else if (flowParams.callbackUrl && !parsedCallbackUrl) {
-            throw new InvalidParamValueException_1.InvalidParamValueException('callbackUrl', flowParams.callbackUrl, 'the URL is malformed');
+    async extractFlowDependencies(flow, nameToIdMap) {
+        const initialState = flow.browser?.initialState;
+        if (!initialState) {
+            return [];
         }
-        this.validateFlowName(flowParams.name);
-        switch (initialRunMode) {
-            case 'AUTONOMOUS':
-                if ((flowParams.overallObjective?.trim().length ?? 0) === 0) {
-                    throw new InvalidParamValueException_1.InvalidParamValueException('overallObjective', flowParams.overallObjective, `'initialRunMode' has a value of '${initialRunMode}'`);
+        switch (initialState.type) {
+            case 'id':
+                // Direct flow ID reference
+                try {
+                    await this.getFlowById(initialState.value);
+                    return [initialState.value];
                 }
-                if (!gptClient) {
-                    throw new InvalidParamValueException_1.InvalidParamValueException('initialRunMode', initialRunMode, `no GPT client is available`);
+                catch (_error) {
+                    Logger_1.appLogger.warn(`Flow dependency not found: flow with ID "${initialState.value}" does not exist`);
+                    return [];
                 }
-                break;
-            case 'INSTRUCT':
-                break;
-            case 'DETERMINISTIC':
-                break;
+            case 'name':
+                // Flow name reference - resolve to ID
+                const flowId = nameToIdMap.get(initialState.value);
+                if (flowId) {
+                    return [flowId];
+                }
+                // If not in our current map, try to find it by querying all flows
+                try {
+                    const dependentFlow = await this.getFlowByName(initialState.value);
+                    nameToIdMap.set(initialState.value, dependentFlow.id);
+                    return [dependentFlow.id];
+                }
+                catch (_error) {
+                    Logger_1.appLogger.warn(`Flow dependency not found: flow with name "${initialState.value}" does not exist`);
+                    return [];
+                }
+            case 'json':
+                // Direct JSON state - no dependencies
+                return [];
             default:
-                throw new InvalidParamValueException_1.InvalidParamValueException('initialRunMode', initialRunMode);
-        }
-        if (!gptClient) {
-            await this.checkIfAnyToolsRequireGpt(flowParams.allowedTools ?? null, flowParams.toolCallsOnStart ?? null);
-        }
-    }
-    async setupAllowedTools(flowParams, hasGptClient) {
-        const customTools = flowParams.customTools?.map((tool) => new CustomToolRunnerTool_1.CustomToolRunnerTool(tool)) ??
-            [];
-        const toolsNeededOnStart = flowParams.toolCallsOnStart?.map((t) => t.name) ?? [];
-        let prepackagedTools;
-        if (flowParams.allowedTools?.length) {
-            const allowedTools = [...toolsNeededOnStart, ...flowParams.allowedTools];
-            // The user has specified a list of tools to use.
-            prepackagedTools = (await ToolManager_1.ToolManager.allTools()).filter((tool) => allowedTools.includes(tool.name));
-        }
-        else {
-            // The user has not specified a list of tools to use, so use the default.
-            const defaultTools = await ToolManager_1.ToolManager.defaultTools();
-            const allowedTools = [
-                ...toolsNeededOnStart,
-                ...defaultTools.map((t) => t.name),
-            ];
-            prepackagedTools = (await ToolManager_1.ToolManager.allTools()).filter((tool) => allowedTools.includes(tool.name));
-        }
-        // If there is no GPT client, only include tools that do not require it.
-        const prepackagedToolsWithGptFiltered = prepackagedTools.filter((tool) => {
-            return hasGptClient || !tool.requiresGpt;
-        });
-        return [...customTools, ...prepackagedToolsWithGptFiltered];
-    }
-    prepareInitialToolCalls(flowParams) {
-        if (!flowParams.toolCallsOnStart?.length && flowParams.targetWebsite) {
-            return [
-                {
-                    name: GoToWebpageTool_1.GoToWebpageTool.NAME,
-                    parameters: {
-                        rationale: 'Initializing web navigation.',
-                        url: flowParams.targetWebsite.toString(),
-                    },
-                },
-            ];
-        }
-        if (flowParams.toolCallsOnStart) {
-            return flowParams.toolCallsOnStart;
-        }
-        else {
-            return [];
-        }
-    }
-    /**
-     * This method creates a temporary directory for the flow with the given ID,
-     * returning the path to the directory.
-     */
-    createTempDirectoryForFlow(flowId) {
-        const tempDir = path.join((0, os_1.tmpdir)(), flowId);
-        fs.mkdirSync(tempDir);
-        return tempDir;
-    }
-    removeTempDirectoryForFlow(flowId) {
-        try {
-            const tempDir = path.join((0, os_1.tmpdir)(), flowId);
-            fs.rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch (error) {
-            Logger_1.appLogger.error('Failed to remove temporary directory:', error);
-        }
-    }
-    /**
-     * Searches the given directory for the largest video file and sets it as the
-     * flow's video. This should be called after the flow has completed.
-     */
-    async setFlowVideo(flowId, flowTempDir, flowsPersistence) {
-        const files = fs
-            .readdirSync(flowTempDir)
-            .filter((file) => file.endsWith('.webm'))
-            .map((file) => path.join(flowTempDir, file));
-        const videoPath = files.length
-            ? files.reduce((a, b) => fs.statSync(a).size > fs.statSync(b).size ? a : b)
-            : null;
-        if (videoPath) {
-            const videoBytes = fs.readFileSync(videoPath);
-            await flowsPersistence.setVideo(flowId, videoBytes);
-        }
-    }
-    isLocallyRunning() {
-        return this.deploymentEnvironment === 'LOCAL';
-    }
-    async checkIfAnyToolsRequireGpt(requestedTools, toolCallsOnStart) {
-        const toolMap = new Map((await ToolManager_1.ToolManager.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]);
-        }
-        const toolCallsRequiringGpt = toolCallsOnStart?.filter((call) => toolMap.get(call.name)?.requiresGpt);
-        if (toolCallsRequiringGpt?.length) {
-            throw new ToolRequiresGptException_1.ToolRequiresGptException(toolCallsRequiringGpt[0].name);
-        }
-    }
-    /**
-     * Parses the given argument as a URL, returning null on failure.
-     */
-    static parseUrl(url) {
-        if (!url) {
-            return null;
-        }
-        try {
-            return new URL(url);
-        }
-        catch (_) {
-            return null;
-        }
-    }
-    /**
-     * Parse a composite page token into pagination state
-     */
-    parseCompositePageToken(token) {
-        if (!token) {
-            return {
-                sourceTokens: {},
-                exhaustedSources: [],
-                cursorTimestamp: null,
-            };
-        }
-        try {
-            return JSON.parse(Buffer.from(token, 'base64').toString('utf8'));
-        }
-        catch (_error) {
-            // If token parsing fails, start fresh
-            return {
-                sourceTokens: {},
-                exhaustedSources: [],
-                cursorTimestamp: null,
-            };
+                Logger_1.appLogger.warn(`Unknown browser state reference type: ${initialState.type}`);
+                return [];
         }
     }
-    /**
-     * Create a composite page token from pagination state
-     */
-    createCompositePageToken(state) {
-        return Buffer.from(JSON.stringify(state)).toString('base64');
-    }
     /**
      * Resolves the complete set of flow IDs including all transitive dependencies.
      * Uses breadth-first search to discover all dependencies recursively.
@@ -954,54 +746,11 @@ class DonobuFlowsManager {
             }
             catch (_error) {
                 // If a flow doesn't exist, skip it but continue processing
-                console.warn(`Flow ${currentFlowId} not found, skipping dependency resolution for this flow`);
+                Logger_1.appLogger.warn(`Flow ${currentFlowId} not found, skipping dependency resolution for this flow`);
             }
         }
         return Array.from(resolvedFlowIds);
     }
-    /**
-     * Extracts dependencies for a single flow by analyzing its browser.initialState
-     */
-    async extractFlowDependencies(flow, nameToIdMap) {
-        const initialState = flow.browser?.initialState;
-        if (!initialState) {
-            return [];
-        }
-        switch (initialState.type) {
-            case 'id':
-                // Direct flow ID reference
-                try {
-                    await this.getFlowById(initialState.value);
-                    return [initialState.value];
-                }
-                catch (_error) {
-                    console.warn(`Flow dependency not found: flow with ID "${initialState.value}" does not exist`);
-                    return [];
-                }
-            case 'name':
-                // Flow name reference - resolve to ID
-                const flowId = nameToIdMap.get(initialState.value);
-                if (flowId) {
-                    return [flowId];
-                }
-                // If not in our current map, try to find it by querying all flows
-                try {
-                    const dependentFlow = await this.getFlowByName(initialState.value);
-                    nameToIdMap.set(initialState.value, dependentFlow.id);
-                    return [dependentFlow.id];
-                }
-                catch (_error) {
-                    console.warn(`Flow dependency not found: flow with name "${initialState.value}" does not exist`);
-                    return [];
-                }
-            case 'json':
-                // Direct JSON state - no dependencies
-                return [];
-            default:
-                console.warn(`Unknown browser state reference type: ${initialState.type}`);
-                return [];
-        }
-    }
     /**
      * Determines if a new flow ID should replace an existing flow ID in the name mapping.
      */
@@ -1016,9 +765,281 @@ class DonobuFlowsManager {
             return true;
         }
     }
+    isLocallyRunning() {
+        return this.deploymentEnvironment === 'LOCAL';
+    }
 }
 exports.DonobuFlowsManager = DonobuFlowsManager;
 DonobuFlowsManager.DEFAULT_MESSAGE_DURATION = 2247;
 DonobuFlowsManager.DEFAULT_MAX_TOOL_CALLS = 50;
 DonobuFlowsManager.DEFAULT_BROWSER_STATE_FILENAME = 'browserstate.json';
+/**
+ * Extracts environment variable names from the given objective and combines
+ * it with the given explicitly allowed variables.
+ *
+ * This function performs two operations:
+ * 1. Extracts environment variable references (in the form `$.env.VARIABLE_NAME`) from the overall objective.
+ * 2. Combines these with any explicitly allowed environment variable names.
+ *
+ * The resulting array contains unique environment variable names without duplicates.
+ *
+ * @param overallObjective - The objective text that may contain environment variable references.
+ * @param explicitlyAllowedEnvVariableNames - Additional environment variable names explicitly allowed.
+ * @returns An array of unique environment variable names that are allowed to be accessed.
+ *
+ * @example
+ * // Returns ["API_KEY", "USER_NAME", "DEBUG_MODE"]
+ * distillAllowedEnvVariableNames(
+ *   "Use {{$.env.API_KEY}} to authenticate and greet {{$.env.USER_NAME}}",
+ *   ["API_KEY", "DEBUG_MODE"]
+ * );
+ */
+function distillAllowedEnvVariableNames(overallObjective, explicitlyAllowedEnvVariableNames) {
+    let allowedEnvVarsByName = overallObjective
+        ? (0, TemplateInterpolator_1.extractInterpolationExpressions)(overallObjective)
+            .filter((exp) => {
+            return exp.startsWith('$.env.');
+        })
+            .map((exp) => {
+            return exp.substring('$.env.'.length);
+        })
+        : [];
+    // Concatonate that with the explicitly requested environment variables.
+    allowedEnvVarsByName = Array.from(new Set(allowedEnvVarsByName.concat(explicitlyAllowedEnvVariableNames ?? [])));
+    return allowedEnvVarsByName;
+}
+/**
+ * Returns a browser config that points to BrowserBase if the
+ * BROWSERBASE_PROJECT_ID and BROWSERBASE_API_KEY environment variables are
+ * present, otherwise, returns back a basic config that uses local Chromium.
+ */
+function getDefaultBrowserConfig(environ) {
+    const browserBaseProjectId = environ.data.BROWSERBASE_PROJECT_ID;
+    if (browserBaseProjectId && environ.data.BROWSERBASE_API_KEY) {
+        return {
+            initialState: undefined,
+            persistState: false,
+            using: {
+                type: 'browserBase',
+                sessionArgs: {
+                    projectId: browserBaseProjectId,
+                    browserSettings: {
+                        advancedStealth: false, // Advanced Stealth is only available on BrowserBase enterprise plans.
+                    },
+                    keepAlive: false,
+                    proxies: false,
+                },
+            },
+        };
+    }
+    else {
+        return {
+            initialState: undefined,
+            persistState: false,
+            using: {
+                type: 'device',
+                deviceName: 'Desktop Chromium',
+                headless: false,
+            },
+        };
+    }
+}
+/**
+ * Parses the given argument as a URL, returning null on failure.
+ */
+function parseUrl(url) {
+    if (!url) {
+        return null;
+    }
+    try {
+        return new URL(url);
+    }
+    catch (_) {
+        return null;
+    }
+}
+/**
+ * Create a composite page token from pagination state
+ */
+function createCompositePageToken(state) {
+    return Buffer.from(JSON.stringify(state)).toString('base64');
+}
+function validateFlowName(flowName) {
+    if (flowName && flowName.length > 255) {
+        throw new InvalidParamValueException_1.InvalidParamValueException('name', flowName, 'the value cannot be longer than 255 characters');
+    }
+}
+async function validateFlowParams(flowParams, gptClient, initialRunMode) {
+    const validTargetWebsiteProtocols = ['https:', 'http:'];
+    const validCallbackUrlProtocols = ['https:', 'http:'];
+    const parsedTargetWebsite = parseUrl(flowParams.targetWebsite);
+    const parsedCallbackUrl = parseUrl(flowParams.callbackUrl);
+    if (parsedTargetWebsite &&
+        !validTargetWebsiteProtocols.some((protocol) => protocol === parsedTargetWebsite.protocol)) {
+        throw new InvalidParamValueException_1.InvalidParamValueException('targetWebsite', flowParams.targetWebsite, 'the URL must start with a supported protocol (example: "https://")');
+    }
+    else if (flowParams.targetWebsite && !parsedTargetWebsite) {
+        throw new InvalidParamValueException_1.InvalidParamValueException('targetWebsite', flowParams.targetWebsite, 'the URL is malformed');
+    }
+    if (parsedCallbackUrl &&
+        !validCallbackUrlProtocols.some((protocol) => protocol === parsedCallbackUrl.protocol)) {
+        throw new InvalidParamValueException_1.InvalidParamValueException('callbackUrl', flowParams.callbackUrl, 'the URL must start with a supported protocol (example: "https://")');
+    }
+    else if (flowParams.callbackUrl && !parsedCallbackUrl) {
+        throw new InvalidParamValueException_1.InvalidParamValueException('callbackUrl', flowParams.callbackUrl, 'the URL is malformed');
+    }
+    validateFlowName(flowParams.name);
+    switch (initialRunMode) {
+        case 'AUTONOMOUS':
+            if ((flowParams.overallObjective?.trim().length ?? 0) === 0) {
+                throw new InvalidParamValueException_1.InvalidParamValueException('overallObjective', flowParams.overallObjective, `'initialRunMode' has a value of '${initialRunMode}'`);
+            }
+            if (!gptClient) {
+                throw new InvalidParamValueException_1.InvalidParamValueException('initialRunMode', initialRunMode, `no GPT client is available`);
+            }
+            break;
+        case 'INSTRUCT':
+            break;
+        case 'DETERMINISTIC':
+            break;
+        default:
+            throw new InvalidParamValueException_1.InvalidParamValueException('initialRunMode', initialRunMode);
+    }
+    if (!gptClient) {
+        await throwIfAnyToolsRequireGpt(flowParams.allowedTools ?? null, flowParams.toolCallsOnStart ?? null);
+    }
+}
+async function setupAllowedTools(flowParams, hasGptClient) {
+    const customTools = flowParams.customTools?.map((tool) => new CustomToolRunnerTool_1.CustomToolRunnerTool(tool)) ?? [];
+    const toolsNeededOnStart = flowParams.toolCallsOnStart?.map((t) => t.name) ?? [];
+    let prepackagedTools;
+    if (flowParams.allowedTools?.length) {
+        const allowedTools = [...toolsNeededOnStart, ...flowParams.allowedTools];
+        // The user has specified a list of tools to use.
+        prepackagedTools = (await ToolManager_1.ToolManager.allTools()).filter((tool) => allowedTools.includes(tool.name));
+    }
+    else {
+        // The user has not specified a list of tools to use, so use the default.
+        const defaultTools = await ToolManager_1.ToolManager.defaultTools();
+        const allowedTools = [
+            ...toolsNeededOnStart,
+            ...defaultTools.map((t) => t.name),
+        ];
+        prepackagedTools = (await ToolManager_1.ToolManager.allTools()).filter((tool) => allowedTools.includes(tool.name));
+    }
+    // If there is no GPT client, only include tools that do not require it.
+    const prepackagedToolsWithGptFiltered = prepackagedTools.filter((tool) => {
+        return hasGptClient || !tool.requiresGpt;
+    });
+    const minimalTools = await ToolManager_1.ToolManager.minimalTools();
+    const existingToolNames = new Set([...customTools, ...prepackagedToolsWithGptFiltered].map((tool) => tool.name));
+    const missingMinimalTools = minimalTools.filter((tool) => !existingToolNames.has(tool.name));
+    const combinedTools = [
+        ...customTools,
+        ...prepackagedToolsWithGptFiltered,
+        ...missingMinimalTools,
+    ];
+    const dedupedTools = Array.from(combinedTools
+        .reduce((uniqueTools, tool) => {
+        if (!uniqueTools.has(tool.name)) {
+            uniqueTools.set(tool.name, tool);
+        }
+        return uniqueTools;
+    }, new Map())
+        .values());
+    return dedupedTools.sort((a, b) => a.name.localeCompare(b.name));
+}
+function prepareInitialToolCalls(flowParams) {
+    if (!flowParams.toolCallsOnStart?.length && flowParams.targetWebsite) {
+        return [
+            {
+                name: GoToWebpageTool_1.GoToWebpageTool.NAME,
+                parameters: {
+                    rationale: 'Initializing web navigation.',
+                    url: flowParams.targetWebsite.toString(),
+                },
+            },
+        ];
+    }
+    if (flowParams.toolCallsOnStart) {
+        return flowParams.toolCallsOnStart;
+    }
+    else {
+        return [];
+    }
+}
+/**
+ * This method creates a temporary directory for the flow with the given ID,
+ * returning the path to the directory.
+ */
+async function createTempDirectoryForFlow(flowId) {
+    const tempDir = path.join((0, os_1.tmpdir)(), flowId);
+    await fs.mkdir(tempDir);
+    return tempDir;
+}
+async function removeTempDirectoryForFlow(flowId) {
+    try {
+        const tempDir = path.join((0, os_1.tmpdir)(), flowId);
+        await fs.rm(tempDir, { recursive: true, force: true });
+    }
+    catch (error) {
+        Logger_1.appLogger.error('Failed to remove temporary directory:', error);
+    }
+}
+/**
+ * Searches the given directory for the largest video file and sets it as the
+ * flow's video. This should be called after the flow has completed.
+ */
+async function setFlowVideo(flowId, flowTempDir, flowsPersistence) {
+    const files = (await fs.readdir(flowTempDir))
+        .filter((file) => file.endsWith('.webm'))
+        .map((file) => path.join(flowTempDir, file));
+    if (!files.length) {
+        return;
+    }
+    const filesWithSizes = await Promise.all(files.map(async (filePath) => ({
+        filePath,
+        size: (await fs.stat(filePath)).size,
+    })));
+    const largestFile = filesWithSizes.reduce((largest, current) => current.size > largest.size ? current : largest);
+    const videoPath = largestFile?.filePath ?? null;
+    if (videoPath) {
+        const videoBytes = await fs.readFile(videoPath);
+        await flowsPersistence.setVideo(flowId, videoBytes);
+    }
+}
+async function throwIfAnyToolsRequireGpt(requestedTools, toolCallsOnStart) {
+    const toolMap = new Map((await ToolManager_1.ToolManager.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]);
+    }
+    const toolCallsRequiringGpt = toolCallsOnStart?.filter((call) => toolMap.get(call.name)?.requiresGpt);
+    if (toolCallsRequiringGpt?.length) {
+        throw new ToolRequiresGptException_1.ToolRequiresGptException(toolCallsRequiringGpt[0].name);
+    }
+}
+/**
+ * Parse a composite page token into pagination state
+ */
+function parseCompositePageToken(token) {
+    if (!token) {
+        return {
+            sourceTokens: {},
+            exhaustedSources: [],
+            cursorTimestamp: null,
+        };
+    }
+    try {
+        return JSON.parse(Buffer.from(token, 'base64').toString('utf8'));
+    }
+    catch (_error) {
+        // If token parsing fails, start fresh
+        return {
+            sourceTokens: {},
+            exhaustedSources: [],
+            cursorTimestamp: null,
+        };
+    }
+}
 //# sourceMappingURL=DonobuFlowsManager.js.map