windmill-components 1.677.0 → 1.687.0

package/package/components/flows/flowDiffManager.svelte.test.js

@@ -1,9 +1,16 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi } from 'vitest';
 import { flushSync } from 'svelte';
 import { createFlowDiffManager } from './flowDiffManager.svelte';
 import { DUPLICATE_MODULE_PREFIX, NEW_MODULE_PREFIX } from './flowDiff';
 import { SPECIAL_MODULE_IDS } from '../copilot/chat/shared';
-import { createRawScriptModule, createForloopModule, createBranchOneModule, createBranchAllModule, createExtendedOpenFlow, createFlowStore, deepClone, expectModuleOrder, createIdentityModule } from './flowDiff.testUtils';
+import { createRawScriptModule, createForloopModule, createBranchOneModule, createBranchAllModule, createExtendedOpenFlow, createFlowStore, createFlowWithSpecialModules, deepClone, expectModuleOrder, createIdentityModule, createAiAgentModule, createFlowModuleTool } from './flowDiff.testUtils';
+vi.mock('../copilot/chat/shared', () => ({
+    SPECIAL_MODULE_IDS: {
+        INPUT: 'Input',
+        PREPROCESSOR: 'preprocessor',
+        FAILURE: 'failure'
+    }
+}));
 describe('FlowDiffManager', () => {
     describe('effect auto-computation', () => {
         it('auto-computes moduleActions when flows differ', () => {
@@ -153,6 +160,30 @@ describe('FlowDiffManager', () => {
             });
             cleanup();
         });
+        it('accepts added preprocessor module - stores it on beforeFlow', () => {
+            const cleanup = $effect.root(() => {
+                const manager = createFlowDiffManager({ testMode: true });
+                const preprocessor = createRawScriptModule(SPECIAL_MODULE_IDS.PREPROCESSOR, 'prep');
+                const beforeFlow = createExtendedOpenFlow({ modules: [] });
+                const afterFlow = createFlowWithSpecialModules({
+                    preprocessor_module: deepClone(preprocessor)
+                });
+                manager.setEditMode(true);
+                manager.setBeforeFlow(beforeFlow);
+                manager.setCurrentFlow(afterFlow);
+                flushSync();
+                expect(manager.moduleActions[SPECIAL_MODULE_IDS.PREPROCESSOR]).toEqual({
+                    action: 'added',
+                    pending: true
+                });
+                manager.acceptModule(SPECIAL_MODULE_IDS.PREPROCESSOR);
+                flushSync();
+                expect(manager.beforeFlow?.value.preprocessor_module?.id).toBe(SPECIAL_MODULE_IDS.PREPROCESSOR);
+                expect(manager.beforeFlow?.value.preprocessor_module?.value
+                    ?.content).toBe('prep');
+            });
+            cleanup();
+        });
         it('handles duplicate ID prefix (old__) for type changes', () => {
             const cleanup = $effect.root(() => {
                 const manager = createFlowDiffManager({ testMode: true });
@@ -274,6 +305,29 @@ describe('FlowDiffManager', () => {
             });
             cleanup();
         });
+        it('rejects removed failure module - restores it on flowStore', () => {
+            const cleanup = $effect.root(() => {
+                const manager = createFlowDiffManager({ testMode: true });
+                const failure = createRawScriptModule(SPECIAL_MODULE_IDS.FAILURE, 'fail');
+                const beforeFlow = createExtendedOpenFlow(createFlowWithSpecialModules({
+                    failure_module: deepClone(failure)
+                }));
+                const flowStore = createFlowStore(createExtendedOpenFlow({ modules: [] }));
+                manager.setEditMode(true);
+                manager.setBeforeFlow(beforeFlow);
+                manager.setCurrentFlow(flowStore.val.value);
+                flushSync();
+                expect(manager.moduleActions[SPECIAL_MODULE_IDS.FAILURE]).toEqual({
+                    action: 'removed',
+                    pending: true
+                });
+                manager.rejectModule(SPECIAL_MODULE_IDS.FAILURE, flowStore);
+                flushSync();
+                expect(flowStore.val.value.failure_module?.id).toBe(SPECIAL_MODULE_IDS.FAILURE);
+                expect(flowStore.val.value.failure_module?.value?.content).toBe('fail');
+            });
+            cleanup();
+        });
         it('does not crash without flowStore', () => {
             const cleanup = $effect.root(() => {
                 const manager = createFlowDiffManager({ testMode: true });
@@ -1251,5 +1305,52 @@ describe('FlowDiffManager', () => {
             });
             cleanup();
         });
+        it('accepts an added ai agent tool into beforeFlow', () => {
+            const cleanup = $effect.root(() => {
+                const manager = createFlowDiffManager({ testMode: true });
+                const lookupTool = createFlowModuleTool(createRawScriptModule('lookup_user', 'lookup'));
+                const sumTool = createFlowModuleTool(createRawScriptModule('sum', 'sum'));
+                const beforeFlow = createExtendedOpenFlow({
+                    modules: [createAiAgentModule('agent', [deepClone(lookupTool)])]
+                });
+                const currentFlowValue = {
+                    modules: [createAiAgentModule('agent', [deepClone(lookupTool), deepClone(sumTool)])]
+                };
+                manager.setEditMode(true);
+                manager.setBeforeFlow(beforeFlow);
+                manager.setCurrentFlow(currentFlowValue);
+                flushSync();
+                expect(manager.moduleActions['sum']).toEqual({ action: 'added', pending: true });
+                manager.acceptModule('sum');
+                flushSync();
+                const tools = (((manager.beforeFlow?.value.modules ?? [])[0]?.value).tools ?? []);
+                expect(tools.map((tool) => tool.id)).toEqual(['lookup_user', 'sum']);
+            });
+            cleanup();
+        });
+        it('rejects a removed ai agent tool back into the live flow', () => {
+            const cleanup = $effect.root(() => {
+                const manager = createFlowDiffManager({ testMode: true });
+                const lookupTool = createFlowModuleTool(createRawScriptModule('lookup_user', 'lookup'));
+                const sumTool = createFlowModuleTool(createRawScriptModule('sum', 'sum'));
+                const beforeFlow = createExtendedOpenFlow({
+                    modules: [createAiAgentModule('agent', [deepClone(lookupTool), deepClone(sumTool)])]
+                });
+                const currentFlowValue = {
+                    modules: [createAiAgentModule('agent', [deepClone(lookupTool)])]
+                };
+                const flowStore = createFlowStore(createExtendedOpenFlow(currentFlowValue));
+                manager.setEditMode(true);
+                manager.setBeforeFlow(beforeFlow);
+                manager.setCurrentFlow(flowStore.val.value);
+                flushSync();
+                expect(manager.moduleActions['sum']).toEqual({ action: 'removed', pending: true });
+                manager.rejectModule('sum', flowStore);
+                flushSync();
+                const tools = (((flowStore.val.value.modules ?? [])[0]?.value).tools ?? []);
+                expect(tools.map((tool) => tool.id)).toEqual(['lookup_user', 'sum']);
+            });
+            cleanup();
+        });
     });
 });

package/package/components/flows/flowExplorer.d.ts

@@ -1,5 +1,9 @@
 import type { FlowModule, OpenFlow } from '../../gen';
 type ModuleBranches = FlowModule[][];
+/**
+ * Returns read-only child-module branches for explorer/search-style consumers.
+ * Structural knowledge lives in `flowTree.ts`; this file is a thin read-only adapter.
+ */
 export declare function getSubModules(flowModule: FlowModule): ModuleBranches;
 export declare function getAllSubmodules(flowModule: FlowModule): ModuleBranches;
 export declare function getAllModules(flow_modules: FlowModule[], failure_module?: FlowModule): FlowModule[];

package/package/components/flows/flowExplorer.js

@@ -1,37 +1,14 @@
-import { isFlowModuleTool } from './agentToolUtils';
+import { collectDescendantFlowModules, getChildModuleBranches } from './flowTree';
+/**
+ * Returns read-only child-module branches for explorer/search-style consumers.
+ * Structural knowledge lives in `flowTree.ts`; this file is a thin read-only adapter.
+ */
 export function getSubModules(flowModule) {
-    if (flowModule.value.type === 'forloopflow' || flowModule.value.type === 'whileloopflow') {
-        return [flowModule.value.modules];
-    }
-    else if (flowModule.value.type === 'branchall') {
-        return flowModule.value.branches.map((branch) => branch.modules);
-    }
-    else if (flowModule.value.type == 'branchone') {
-        return [...flowModule.value.branches.map((branch) => branch.modules), flowModule.value.default];
-    }
-    else if (flowModule.value.type === 'aiagent') {
-        // Return AI agent tools as pseudo-FlowModules for searching
-        if (flowModule.value.tools) {
-            return [
-                flowModule.value.tools
-                    .filter(isFlowModuleTool)
-                    .map((tool) => ({
-                    id: tool.id,
-                    value: tool.value,
-                    summary: tool.summary
-                }))
-            ];
-        }
-    }
-    return [];
+    return getChildModuleBranches(flowModule);
 }
 export function getAllSubmodules(flowModule) {
     return getSubModules(flowModule).map((modules) => {
-        return modules
-            .map((module) => {
-            return [module, ...getAllSubmodules(module).flat()];
-        })
-            .flat();
+        return modules.flatMap((module) => [module, ...collectDescendantFlowModules(module)]);
     });
 }
 export function getAllModules(flow_modules, failure_module) {

package/package/components/flows/flowState.d.ts

@@ -7,6 +7,7 @@ export type FlowModuleState = {
     previewArgs?: any;
     previewJobId?: string;
     previewSuccess?: boolean;
+    previewLogs?: string;
 };
 export type FlowState = Record<string, FlowModuleState>;
 /**

package/package/components/flows/flowStateUtils.svelte.js

@@ -1,5 +1,6 @@
 import { ScriptService } from '../../gen';
 import { initialCode } from '../../script_helpers';
+import { inferAssets } from '../../infer';
 import { userStore, workspaceStore } from '../../stores';
 import { getScriptByPath } from '../../scripts';
 import { get } from 'svelte/store';
@@ -47,6 +48,9 @@ export async function pickFlow(path, summary, id) {
 }
 export async function createInlineScriptModule(language, kind, subkind, id, summary) {
     const code = initialCode(language, kind, subkind);
+    // Needed when the predefined code has assets in it
+    const inferResult = await inferAssets(language, code);
+    const assets = inferResult.status === 'ok' && inferResult.assets.length > 0 ? inferResult.assets : undefined;
     const flowModule = {
         id,
         summary,
@@ -55,7 +59,8 @@ export async function createInlineScriptModule(language, kind, subkind, id, summ
             content: code,
             language,
             input_transforms: {},
-            ...(kind === 'trigger' ? { is_trigger: true } : {})
+            ...(kind === 'trigger' ? { is_trigger: true } : {}),
+            ...(assets ? { assets } : {})
         }
     };
     return [flowModule, await loadFlowModuleState(flowModule)];

package/package/components/flows/flowStore.svelte.d.ts

@@ -65,7 +65,7 @@ export declare function getFirstStepSchema(flowState: FlowState, flow: OpenFlow)
         id: string;
         summary: string | undefined;
         value: {
-            language?: "deno" | "bun" | "python3" | "go" | "bash" | "powershell" | "postgresql" | "mysql" | "bigquery" | "snowflake" | "mssql" | "oracledb" | "graphql" | "nativets" | "php" | "rust" | "ansible" | "csharp" | "nu" | "java" | "ruby" | "duckdb" | undefined;
+            language?: "deno" | "bun" | "python3" | "go" | "bash" | "powershell" | "postgresql" | "mysql" | "bigquery" | "snowflake" | "mssql" | "oracledb" | "graphql" | "nativets" | "php" | "rust" | "ansible" | "csharp" | "nu" | "java" | "ruby" | "rlang" | "duckdb" | undefined;
             path?: string | undefined;
             type: "rawscript" | "script" | "flow" | "forloopflow" | "whileloopflow" | "branchone" | "branchall" | "aiagent" | "identity";
         };

package/package/components/flows/flowTree.d.ts

@@ -0,0 +1,91 @@
+import type { FlowModule } from '../../gen';
+export type FlowModuleTree = {
+    modules?: FlowModule[] | null;
+    failure_module?: FlowModule | null;
+    preprocessor_module?: FlowModule | null;
+};
+export type ModuleParentLocation = {
+    type: 'root';
+    index: number;
+} | {
+    type: 'forloop' | 'whileloop';
+    parentId: string;
+    index: number;
+} | {
+    type: 'branchone-default';
+    parentId: string;
+    index: number;
+} | {
+    type: 'branchone-branch';
+    parentId: string;
+    branchIndex: number;
+    index: number;
+} | {
+    type: 'branchall-branch';
+    parentId: string;
+    branchIndex: number;
+    index: number;
+} | {
+    type: 'aiagent';
+    parentId: string;
+    index: number;
+} | {
+    type: 'failure';
+    index: -1;
+} | {
+    type: 'preprocessor';
+    index: -1;
+};
+export type ArrayBackedModuleParentLocation = Exclude<ModuleParentLocation, {
+    type: 'failure';
+    index: -1;
+} | {
+    type: 'preprocessor';
+    index: -1;
+}>;
+type ArrayBackedFlowNodeMatch = {
+    module: FlowModule;
+    location: ArrayBackedModuleParentLocation;
+    container: FlowModule[];
+};
+export type FlowNodeMatch = ArrayBackedFlowNodeMatch | {
+    module: FlowModule;
+    location: Extract<ModuleParentLocation, {
+        type: 'failure' | 'preprocessor';
+    }>;
+};
+export type FlowNodeLocation = {
+    module: FlowModule;
+    location: ModuleParentLocation;
+};
+export declare function getChildModuleBranches(module: FlowModule): FlowModule[][];
+export declare function collectDescendantFlowModules(module: FlowModule): FlowModule[];
+/**
+ * Collect every module ID in a flow tree, including ALL aiagent tool IDs
+ * (both flowmodule and non-flowmodule like MCP).  Used for ID uniqueness
+ * validation where every tool's ID must be reserved regardless of type.
+ */
+export declare function collectAllFlowModuleIds(flow: FlowModuleTree): string[];
+/**
+ * Like collectAllFlowModuleIds but operates on a modules array directly
+ * (without failure_module/preprocessor_module).
+ */
+export declare function collectAllFlowModuleIdsFromModules(modules: FlowModule[]): string[];
+export declare function collectFlowNodes(flow: FlowModuleTree): FlowNodeLocation[];
+export declare function findModuleInModules(modules: FlowModule[], moduleId: string): FlowModule | undefined;
+export declare function findFlowNode(flow: FlowModuleTree, moduleId: string): FlowNodeMatch | null;
+/**
+ * Returns the live stored module for any module id in the flow tree.
+ * This includes nested modules, AI-agent flowmodule tools, and special modules.
+ */
+export declare function findModuleInFlow(flow: FlowModuleTree, moduleId: string): FlowModule | null;
+export declare function findModuleParent(flow: FlowModuleTree, moduleId: string): ModuleParentLocation | null;
+export declare function getModuleArrayByLocation(flow: FlowModuleTree, location: ArrayBackedModuleParentLocation): FlowModule[] | null;
+export declare function ensureModuleArrayByLocation(flow: FlowModuleTree, location: ArrayBackedModuleParentLocation, templateFlow?: FlowModuleTree): FlowModule[] | null;
+export declare function getModuleArrayContainer(flow: FlowModuleTree, moduleId: string): {
+    index: number;
+    modules: FlowModule[];
+} | null;
+export declare function removeFlowModule(flow: FlowModuleTree, moduleId: string): FlowModule | null;
+export declare function replaceFlowModule(target: FlowModule, next: FlowModule): FlowModule;
+export {};

package/package/components/flows/flowTree.js

@@ -0,0 +1,326 @@
+function isFlowModuleToolCandidate(tool) {
+    const toolValue = tool.value;
+    return toolValue.tool_type === undefined || toolValue.tool_type === 'flowmodule';
+}
+export function getChildModuleBranches(module) {
+    if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
+        return [module.value.modules];
+    }
+    if (module.value.type === 'branchone') {
+        return [module.value.default, ...module.value.branches.map((branch) => branch.modules)];
+    }
+    if (module.value.type === 'branchall') {
+        return module.value.branches.map((branch) => branch.modules);
+    }
+    if (module.value.type === 'aiagent' && module.value.tools) {
+        return [
+            module.value.tools.filter((tool) => isFlowModuleToolCandidate(tool))
+        ];
+    }
+    return [];
+}
+export function collectDescendantFlowModules(module) {
+    return getChildModuleBranches(module).flatMap((branch) => branch.flatMap((childModule) => [childModule, ...collectDescendantFlowModules(childModule)]));
+}
+function visitNestedFlowNodesOfModule(module, visit) {
+    if (module.value.type === 'aiagent' && module.value.tools) {
+        const tools = module.value.tools;
+        for (let toolIndex = 0; toolIndex < tools.length; toolIndex++) {
+            const tool = tools[toolIndex];
+            if (!isFlowModuleToolCandidate(tool)) {
+                continue;
+            }
+            const toolMatch = {
+                module: tool,
+                location: {
+                    type: 'aiagent',
+                    parentId: module.id,
+                    index: toolIndex
+                },
+                container: tools
+            };
+            if (visit(toolMatch) || visitNestedFlowNodesOfModule(tool, visit)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    const childBranches = getChildModuleBranches(module);
+    for (let branchIndex = 0; branchIndex < childBranches.length; branchIndex++) {
+        const branch = childBranches[branchIndex];
+        const locationBuilder = module.value.type === 'forloopflow'
+            ? (childIndex) => ({
+                type: 'forloop',
+                parentId: module.id,
+                index: childIndex
+            })
+            : module.value.type === 'whileloopflow'
+                ? (childIndex) => ({
+                    type: 'whileloop',
+                    parentId: module.id,
+                    index: childIndex
+                })
+                : module.value.type === 'branchone'
+                    ? branchIndex === 0
+                        ? (childIndex) => ({
+                            type: 'branchone-default',
+                            parentId: module.id,
+                            index: childIndex
+                        })
+                        : (childIndex) => ({
+                            type: 'branchone-branch',
+                            parentId: module.id,
+                            branchIndex: branchIndex - 1,
+                            index: childIndex
+                        })
+                    : (childIndex) => ({
+                        type: 'branchall-branch',
+                        parentId: module.id,
+                        branchIndex,
+                        index: childIndex
+                    });
+        if (visitFlowNodesInModules(branch, locationBuilder, visit)) {
+            return true;
+        }
+    }
+    return false;
+}
+function visitFlowNodesInModules(modules, locationBuilder, visit) {
+    for (let index = 0; index < modules.length; index++) {
+        const module = modules[index];
+        if (visit({
+            module,
+            location: locationBuilder(index),
+            container: modules
+        })) {
+            return true;
+        }
+        if (visitNestedFlowNodesOfModule(module, visit)) {
+            return true;
+        }
+    }
+    return false;
+}
+function findFlowNodeInModules(modules, moduleId, locationBuilder) {
+    let match = null;
+    visitFlowNodesInModules(modules, locationBuilder, (nodeMatch) => {
+        if (nodeMatch.module.id !== moduleId) {
+            return false;
+        }
+        match = nodeMatch;
+        return true;
+    });
+    return match;
+}
+/**
+ * Collect every module ID in a flow tree, including ALL aiagent tool IDs
+ * (both flowmodule and non-flowmodule like MCP).  Used for ID uniqueness
+ * validation where every tool's ID must be reserved regardless of type.
+ */
+export function collectAllFlowModuleIds(flow) {
+    const ids = [];
+    function walkModules(modules) {
+        for (const module of modules) {
+            if (module.id) {
+                ids.push(module.id);
+            }
+            if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
+                walkModules(module.value.modules);
+            }
+            else if (module.value.type === 'branchone') {
+                for (const branch of module.value.branches) {
+                    walkModules(branch.modules);
+                }
+                walkModules(module.value.default);
+            }
+            else if (module.value.type === 'branchall') {
+                for (const branch of module.value.branches) {
+                    walkModules(branch.modules);
+                }
+            }
+            else if (module.value.type === 'aiagent' && module.value.tools) {
+                walkModules(module.value.tools);
+            }
+        }
+    }
+    if (flow.modules) {
+        walkModules(flow.modules);
+    }
+    if (flow.failure_module?.id) {
+        ids.push(flow.failure_module.id);
+    }
+    if (flow.preprocessor_module?.id) {
+        ids.push(flow.preprocessor_module.id);
+    }
+    return ids;
+}
+/**
+ * Like collectAllFlowModuleIds but operates on a modules array directly
+ * (without failure_module/preprocessor_module).
+ */
+export function collectAllFlowModuleIdsFromModules(modules) {
+    return collectAllFlowModuleIds({ modules });
+}
+export function collectFlowNodes(flow) {
+    const matches = [];
+    if (flow.failure_module) {
+        matches.push({
+            module: flow.failure_module,
+            location: { type: 'failure', index: -1 }
+        });
+    }
+    if (flow.preprocessor_module) {
+        matches.push({
+            module: flow.preprocessor_module,
+            location: { type: 'preprocessor', index: -1 }
+        });
+    }
+    visitFlowNodesInModules(flow.modules ?? [], (index) => ({ type: 'root', index }), (match) => {
+        matches.push({
+            module: match.module,
+            location: match.location
+        });
+    });
+    return matches;
+}
+export function findModuleInModules(modules, moduleId) {
+    return (findFlowNodeInModules(modules, moduleId, (index) => ({ type: 'root', index }))?.module ??
+        undefined);
+}
+export function findFlowNode(flow, moduleId) {
+    if (flow.failure_module?.id === moduleId) {
+        return {
+            module: flow.failure_module,
+            location: { type: 'failure', index: -1 }
+        };
+    }
+    if (flow.preprocessor_module?.id === moduleId) {
+        return {
+            module: flow.preprocessor_module,
+            location: { type: 'preprocessor', index: -1 }
+        };
+    }
+    return findFlowNodeInModules(flow.modules ?? [], moduleId, (index) => ({ type: 'root', index }));
+}
+/**
+ * Returns the live stored module for any module id in the flow tree.
+ * This includes nested modules, AI-agent flowmodule tools, and special modules.
+ */
+export function findModuleInFlow(flow, moduleId) {
+    return findFlowNode(flow, moduleId)?.module ?? null;
+}
+export function findModuleParent(flow, moduleId) {
+    return findFlowNode(flow, moduleId)?.location ?? null;
+}
+function resolveModuleArrayByLocation(flow, location, options = {}) {
+    if (location.type === 'root') {
+        if (!flow.modules && options.createIfMissing) {
+            flow.modules = [];
+        }
+        return flow.modules ?? null;
+    }
+    const parentModule = findModuleInFlow(flow, location.parentId);
+    if (!parentModule) {
+        return null;
+    }
+    if (location.type === 'forloop' && parentModule.value.type === 'forloopflow') {
+        return parentModule.value.modules ?? null;
+    }
+    if (location.type === 'whileloop' && parentModule.value.type === 'whileloopflow') {
+        return parentModule.value.modules ?? null;
+    }
+    if (location.type === 'branchone-default' && parentModule.value.type === 'branchone') {
+        return parentModule.value.default ?? null;
+    }
+    if (location.type === 'branchone-branch' && parentModule.value.type === 'branchone') {
+        let branch = parentModule.value.branches[location.branchIndex];
+        if (!branch && options.templateFlow) {
+            const templateParent = findModuleInFlow(options.templateFlow, location.parentId);
+            const templateBranch = templateParent?.value.type === 'branchone'
+                ? templateParent.value.branches[location.branchIndex]
+                : undefined;
+            if (templateBranch) {
+                while (parentModule.value.branches.length <= location.branchIndex) {
+                    parentModule.value.branches.push({ expr: '', modules: [] });
+                }
+                parentModule.value.branches[location.branchIndex] = {
+                    ...templateBranch,
+                    modules: []
+                };
+                branch = parentModule.value.branches[location.branchIndex];
+            }
+        }
+        return branch?.modules ?? null;
+    }
+    if (location.type === 'branchall-branch' && parentModule.value.type === 'branchall') {
+        let branch = parentModule.value.branches[location.branchIndex];
+        if (!branch && options.templateFlow) {
+            const templateParent = findModuleInFlow(options.templateFlow, location.parentId);
+            const templateBranch = templateParent?.value.type === 'branchall'
+                ? templateParent.value.branches[location.branchIndex]
+                : undefined;
+            if (templateBranch) {
+                while (parentModule.value.branches.length <= location.branchIndex) {
+                    parentModule.value.branches.push({ modules: [] });
+                }
+                parentModule.value.branches[location.branchIndex] = {
+                    ...templateBranch,
+                    modules: []
+                };
+                branch = parentModule.value.branches[location.branchIndex];
+            }
+        }
+        return branch?.modules ?? null;
+    }
+    if (location.type === 'aiagent' && parentModule.value.type === 'aiagent') {
+        if (!parentModule.value.tools && options.createIfMissing) {
+            parentModule.value.tools = [];
+        }
+        return parentModule.value.tools ?? null;
+    }
+    return null;
+}
+export function getModuleArrayByLocation(flow, location) {
+    return resolveModuleArrayByLocation(flow, location);
+}
+export function ensureModuleArrayByLocation(flow, location, templateFlow) {
+    return resolveModuleArrayByLocation(flow, location, {
+        createIfMissing: true,
+        templateFlow
+    });
+}
+export function getModuleArrayContainer(flow, moduleId) {
+    const match = findFlowNode(flow, moduleId);
+    if (!match || !('container' in match)) {
+        return null;
+    }
+    return {
+        index: match.location.index,
+        modules: match.container
+    };
+}
+export function removeFlowModule(flow, moduleId) {
+    if (flow.preprocessor_module?.id === moduleId) {
+        const removed = flow.preprocessor_module;
+        flow.preprocessor_module = undefined;
+        return removed;
+    }
+    if (flow.failure_module?.id === moduleId) {
+        const removed = flow.failure_module;
+        flow.failure_module = undefined;
+        return removed;
+    }
+    const match = findFlowNode(flow, moduleId);
+    if (!match || !('container' in match)) {
+        return null;
+    }
+    const [removed] = match.container.splice(match.location.index, 1);
+    return removed ?? null;
+}
+export function replaceFlowModule(target, next) {
+    for (const key of Object.keys(target)) {
+        delete target[key];
+    }
+    Object.assign(target, next);
+    return target;
+}

package/package/components/flows/flowTree.test.d.ts

@@ -0,0 +1 @@
+export {};