windmill-components 1.677.1 → 1.695.0

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

@@ -5,10 +5,9 @@
  * This decouples diff management from specific UI components (like AI chat) and makes it
  * available for any use case that needs to track and apply flow changes.
  */
-import { buildFlowTimeline, insertModuleIntoFlow, findModuleParent, locationsEqual, DUPLICATE_MODULE_PREFIX, NEW_MODULE_PREFIX } from './flowDiff';
+import { buildFlowTimeline, insertModuleIntoFlow, locationsEqual, DUPLICATE_MODULE_PREFIX, NEW_MODULE_PREFIX } from './flowDiff';
+import { findModuleInFlow, findModuleParent, removeFlowModule, replaceFlowModule } from './flowTree';
 import { refreshStateStore } from '../../svelte5Utils.svelte';
-import { getIndexInNestedModules } from '../copilot/chat/flow/utils';
-import { dfs } from './previousResults';
 import { SPECIAL_MODULE_IDS } from '../copilot/chat/shared';
 /**
  * Creates a flow diff manager instance
@@ -26,7 +25,7 @@ function createSkeletonModule(module) {
         clone.value.branches.forEach((b) => (b.modules = []));
     }
     else if (clone.value.type === 'aiagent') {
-        clone.value.tools = [];
+        clone.value.tools = (clone.value.tools ?? []).filter((t) => t.value?.tool_type && t.value.tool_type !== 'flowmodule');
     }
     return clone;
 }
@@ -134,47 +133,12 @@ export function createFlowDiffManager({ testMode = false } = {}) {
     function setModuleActions(actions) {
         updateModuleActions(actions);
     }
-    /**
-     * Helper to get a module from a flow by ID
-     */
-    function getModuleFromFlow(id, flow) {
-        if (flow.value.preprocessor_module?.id === id) {
-            return flow.value.preprocessor_module;
-        }
-        else if (flow.value.failure_module?.id === id) {
-            return flow.value.failure_module;
-        }
-        else {
-            return dfs(id, flow, false)[0];
-        }
-    }
     /**
      * Internal helper to delete a module from a flow object
      * Returns true if the module was found and deleted, false otherwise
      */
     function deleteModuleInternal(id, flow) {
-        if (flow.value.preprocessor_module?.id === id) {
-            flow.value.preprocessor_module = undefined;
-            return true;
-        }
-        else if (flow.value.failure_module?.id === id) {
-            flow.value.failure_module = undefined;
-            return true;
-        }
-        else {
-            const result = getIndexInNestedModules(flow, id);
-            if (!result) {
-                // Module not found (may have been deleted along with a parent)
-                return false;
-            }
-            const { modules } = result;
-            const index = modules.findIndex((m) => m.id === id);
-            if (index >= 0) {
-                modules.splice(index, 1);
-                return true;
-            }
-            return false;
-        }
+        return removeFlowModule(flow.value, id) !== null;
     }
     /**
      * Helper to delete a module from the flow
@@ -221,7 +185,7 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                 parentLoc.type !== 'root' &&
                 parentLoc.type !== 'failure' &&
                 parentLoc.type !== 'preprocessor') {
-                const parentInBefore = getModuleFromFlow(parentLoc.parentId, beforeFlow);
+                const parentInBefore = findModuleInFlow(beforeFlow.value, parentLoc.parentId) ?? undefined;
                 if (!parentInBefore) {
                     // Parent is missing in beforeFlow. It must be pending acceptance.
                     // Accept as skeleton to avoid auto-accepting all siblings.
@@ -229,13 +193,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                 }
             }
             // Use insertModuleIntoFlow targeting beforeFlow, sourcing position from currentFlow
-            let module = getModuleFromFlow(actualId, {
-                value: currentFlow,
-                summary: ''
-            });
+            let module = findModuleInFlow(currentFlow, actualId) ?? undefined;
             if (module) {
                 // Check if module already exists in beforeFlow (could be a skeleton from earlier acceptance)
-                const existingModule = getModuleFromFlow(actualId, beforeFlow);
+                const existingModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
                 if (existingModule) {
                     // Module exists in beforeFlow - check if it's in the same location
                     const beforeLocation = findModuleParent(beforeFlow.value, actualId);
@@ -245,8 +206,7 @@ export function createFlowDiffManager({ testMode = false } = {}) {
                     if (sameLocation) {
                         // Module is in the same location, update it in-place
                         const moduleToApply = asSkeleton ? createSkeletonModule(module) : module;
-                        Object.keys(existingModule).forEach((k) => delete existingModule[k]);
-                        Object.assign(existingModule, $state.snapshot(moduleToApply));
+                        replaceFlowModule(existingModule, $state.snapshot(moduleToApply));
                     }
                     else {
                         // Module is being moved - insert at new location (the old copy will be removed when old__id is accepted)
@@ -263,14 +223,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
         }
         else if (info.action === 'modified') {
             // Modified: Apply modifications to beforeFlow module
-            const beforeModule = getModuleFromFlow(actualId, beforeFlow);
-            const afterModule = getModuleFromFlow(actualId, {
-                value: currentFlow,
-                summary: ''
-            });
+            const beforeModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
+            const afterModule = findModuleInFlow(currentFlow, actualId) ?? undefined;
             if (beforeModule && afterModule) {
-                Object.keys(beforeModule).forEach((k) => delete beforeModule[k]);
-                Object.assign(beforeModule, $state.snapshot(afterModule));
+                replaceFlowModule(beforeModule, $state.snapshot(afterModule));
             }
         }
     }
@@ -303,11 +259,11 @@ export function createFlowDiffManager({ testMode = false } = {}) {
             else if (info.action === 'removed') {
                 // Removed in after: Restore to flowStore (currentFlow)
                 // Source from beforeFlow
-                const oldModule = getModuleFromFlow(actualId, beforeFlow);
+                const oldModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
                 if (oldModule) {
                     // For type changes (old__ prefix), rename the new module to avoid ID conflict
                     if (id.startsWith(DUPLICATE_MODULE_PREFIX)) {
-                        const existingNew = getModuleFromFlow(actualId, flowStore.val);
+                        const existingNew = findModuleInFlow(flowStore.val.value, actualId) ?? undefined;
                         if (existingNew) {
                             existingNew.id = `${NEW_MODULE_PREFIX}${actualId}`;
                         }
@@ -318,11 +274,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
             }
             else if (info.action === 'modified') {
                 // Modified: Revert modifications in flowStore (currentFlow)
-                const oldModule = getModuleFromFlow(actualId, beforeFlow);
-                const newModule = getModuleFromFlow(actualId, flowStore.val);
+                const oldModule = findModuleInFlow(beforeFlow.value, actualId) ?? undefined;
+                const newModule = findModuleInFlow(flowStore.val.value, actualId) ?? undefined;
                 if (oldModule && newModule) {
-                    Object.keys(newModule).forEach((k) => delete newModule[k]);
-                    Object.assign(newModule, $state.snapshot(oldModule));
+                    replaceFlowModule(newModule, $state.snapshot(oldModule));
                 }
                 refreshStateStore(flowStore);
             }
@@ -391,20 +346,10 @@ export function createFlowDiffManager({ testMode = false } = {}) {
         }
         else {
             // Show module diff
-            const beforeModule = getModuleFromFlow(moduleId, beforeFlow);
-            // Need to check failure_module and preprocessor_module for currentFlow as well
-            let afterModule = undefined;
-            if (currentFlow) {
-                if (currentFlow.preprocessor_module?.id === moduleId) {
-                    afterModule = currentFlow.preprocessor_module;
-                }
-                else if (currentFlow.failure_module?.id === moduleId) {
-                    afterModule = currentFlow.failure_module;
-                }
-                else {
-                    afterModule = dfs(moduleId, { value: currentFlow, summary: '' }, false)[0];
-                }
-            }
+            const beforeModule = findModuleInFlow(beforeFlow.value, moduleId) ?? undefined;
+            const afterModule = currentFlow
+                ? (findModuleInFlow(currentFlow, moduleId) ?? undefined)
+                : undefined;
             if (beforeModule && afterModule) {
                 diffDrawer.openDrawer();
                 diffDrawer.setDiff({

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';
@@ -26,7 +27,11 @@ export async function loadFlowModuleState(flowModule) {
     }
     catch (e) {
         console.debug(e);
-        return emptyFlowModuleState();
+        // Leave schema undefined so onSelectedIdChange in FlowModuleComponent
+        // can detect the failed inference and retry when the module is selected.
+        return {
+            previewResult: NEVER_TESTED_THIS_FAR
+        };
     }
 }
 export async function pickScript(path, summary, id, hash, kind) {
@@ -47,6 +52,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 +63,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/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 {};