windmill-components 1.677.1 → 1.687.0

package/package/components/flows/agentToolTree.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('../aiProviderStorage', () => ({
+    loadStoredConfig: () => undefined
+}));
+vi.mock('./flowInfers', () => ({
+    AI_AGENT_SCHEMA: { properties: {} }
+}));
+import { collectFlowNodeIds, findAgentToolOwner, removeAgentToolOwner } from './agentToolTree';
+function makeRawModule(id) {
+    return {
+        id,
+        summary: id,
+        value: { type: 'rawscript', content: '', language: 'python3', input_transforms: {} }
+    };
+}
+function makeAiAgent(id, tools) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+function makeFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+describe('findAgentToolOwner', () => {
+    it('finds a direct tool owner in an ai agent', () => {
+        const rootAgent = makeAiAgent('root_agent', [makeFlowModuleTool(makeRawModule('lookup_user'))]);
+        expect(findAgentToolOwner([rootAgent], 'lookup_user')).toMatchObject({
+            agentId: 'root_agent',
+            toolIndex: 0,
+            depth: 1
+        });
+    });
+    it('finds a nested tool owner inside a nested ai agent tool', () => {
+        const nestedAgent = makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]);
+        const rootAgent = makeAiAgent('root_agent', [makeFlowModuleTool(nestedAgent)]);
+        expect(findAgentToolOwner([rootAgent], 'create_ticket')).toMatchObject({
+            agentId: 'support_agent',
+            toolIndex: 0,
+            depth: 2
+        });
+    });
+});
+describe('removeAgentToolOwner', () => {
+    it('removes the matched tool and returns its subtree ids', () => {
+        const nestedAgent = makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]);
+        const rootAgent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(nestedAgent)
+        ]);
+        const owner = findAgentToolOwner([rootAgent], 'support_agent');
+        expect(owner).toBeDefined();
+        expect(removeAgentToolOwner(owner)).toEqual({
+            tool: expect.objectContaining({ id: 'support_agent' }),
+            removedIds: ['support_agent', 'create_ticket']
+        });
+        expect(rootAgent.value.tools).toHaveLength(1);
+        expect(rootAgent.value.tools.map((tool) => tool.id)).toEqual(['lookup_user']);
+    });
+});
+describe('collectFlowNodeIds', () => {
+    it('includes ai agent tool ids when deleting an ai agent flow module', () => {
+        const agent = makeAiAgent('root_agent', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        expect(collectFlowNodeIds(agent)).toEqual([
+            'root_agent',
+            'lookup_user',
+            'support_agent',
+            'create_ticket'
+        ]);
+    });
+});

package/package/components/flows/agentToolUtils.d.ts

@@ -51,11 +51,6 @@ export declare function createMcpTool(id: string): McpTool;
  * Create a Websearch tool
  */
 export declare function createWebsearchTool(id: string): WebsearchTool;
-/**
- * Remove an AI agent tool by id, recursively traversing nested modules and nested AI agents.
- * Returns true when a matching tool was found and removed.
- */
-export declare function removeAgentToolByIdDeep(modules: FlowModule[], id: string, onRemove?: (tool: AgentTool) => void): boolean;
 /**
  * Convert a FlowModuleTool to a FlowModule for use with loadFlowModuleState etc.
  * Strips the extra `tool_type` field and maps AgentTool fields to FlowModule fields.

package/package/components/flows/agentToolUtils.js

@@ -78,55 +78,6 @@ export function createWebsearchTool(id) {
         }
     };
 }
-/**
- * Remove an AI agent tool by id, recursively traversing nested modules and nested AI agents.
- * Returns true when a matching tool was found and removed.
- */
-export function removeAgentToolByIdDeep(modules, id, onRemove) {
-    for (const module of modules) {
-        if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-            if (removeAgentToolByIdDeep(module.value.modules, id, onRemove)) {
-                return true;
-            }
-            continue;
-        }
-        if (module.value.type === 'branchall') {
-            for (const branch of module.value.branches) {
-                if (removeAgentToolByIdDeep(branch.modules, id, onRemove)) {
-                    return true;
-                }
-            }
-            continue;
-        }
-        if (module.value.type === 'branchone') {
-            if (removeAgentToolByIdDeep(module.value.default, id, onRemove)) {
-                return true;
-            }
-            for (const branch of module.value.branches) {
-                if (removeAgentToolByIdDeep(branch.modules, id, onRemove)) {
-                    return true;
-                }
-            }
-            continue;
-        }
-        if (module.value.type !== 'aiagent') {
-            continue;
-        }
-        const toolIndex = module.value.tools.findIndex((tool) => tool.id === id);
-        if (toolIndex !== -1) {
-            const [removed] = module.value.tools.splice(toolIndex, 1);
-            onRemove?.(removed);
-            return true;
-        }
-        const nestedToolModules = module.value.tools
-            .filter(isFlowModuleTool)
-            .map((tool) => agentToolToFlowModule(tool));
-        if (removeAgentToolByIdDeep(nestedToolModules, id, onRemove)) {
-            return true;
-        }
-    }
-    return false;
-}
 /**
  * Convert a FlowModuleTool to a FlowModule for use with loadFlowModuleState etc.
  * Strips the extra `tool_type` field and maps AgentTool fields to FlowModule fields.

package/package/components/flows/content/FlowLoop.svelte

@@ -198,9 +198,13 @@ let suggestion = $state(undefined);
 											: ''
 									},
 									(value) => {
-										;(mod.value as ForloopFlow).parallelism = {
-											type: 'static',
-											value
+										if (value === '' || value === null || value === undefined) {
+											;(mod.value as ForloopFlow).parallelism = undefined
+										} else {
+											;(mod.value as ForloopFlow).parallelism = {
+												type: 'static',
+												value
+											}
 										}
 									}
 								}
@@ -227,7 +231,6 @@ let suggestion = $state(undefined);
 										}
 									}
 								}}
-								class="h-6"
 							>
 								{#snippet children({ item })}
 									<ToggleButton small label="static" value="static" {item} />

package/package/components/flows/content/FlowModuleDeleteAfterUse.svelte

@@ -1,19 +1,22 @@
 <script lang="ts">import Toggle from '../../Toggle.svelte';
 import Tooltip from '../../Tooltip.svelte';
+import { SecondsInput } from '../../common';
 import Section from '../../Section.svelte';
 let { flowModule = $bindable(), disabled = false } = $props();
+let enabled = $derived(flowModule.delete_after_secs != null);
 </script>
 
-<Section label="Delete after use">
+<Section label="Delete after completion">
 	{#snippet header()}
 		<Tooltip>
 			The logs, arguments and results of this flow step will be completely deleted from Windmill
-			once the flow is complete. They might be temporarily visible in UI while the flow is running.
+			after the specified delay once the flow is complete. They might be temporarily visible in UI
+			while the flow is running.
 			<br />
 			This also applies to a flow step that has failed: the error will not be accessible.
 			<br />
 			<br />
-			The deletion is irreversible.
+			The deletion is irreversible. Set to 0 for immediate deletion.
 			{#if disabled}
 				<br />
 				<br />
@@ -25,16 +28,21 @@ let { flowModule = $bindable(), disabled = false } = $props();
 	<Toggle
 		{disabled}
 		size="sm"
-		checked={Boolean(flowModule.delete_after_use)}
+		checked={enabled}
 		on:change={() => {
-			if (flowModule.delete_after_use) {
-				flowModule.delete_after_use = undefined
+			if (enabled) {
+				flowModule.delete_after_secs = undefined
 			} else {
-				flowModule.delete_after_use = true
+				flowModule.delete_after_secs = 0
 			}
 		}}
 		options={{
 			right: 'Delete logs, arguments and results after the flow is complete'
 		}}
 	/>
+	{#if enabled}
+		<div class="mt-2">
+			<SecondsInput bind:seconds={flowModule.delete_after_secs} {disabled} size="sm" />
+		</div>
+	{/if}
 </Section>

package/package/components/flows/content/FlowSettings.svelte

@@ -96,6 +96,7 @@ let numberOfAdvancedOptionsOn = $derived(activeAdvancedOptionNames.length);
 						}}
 					/>
 				</Label>
+				<!-- prettier-ignore -->
 				<LabelsInput bind:labels={(flowStore.val as any).labels} class="-mt-4" />
 
 				{#if !noEditor}
@@ -560,6 +561,34 @@ let numberOfAdvancedOptionsOn = $derived(activeAdvancedOptionNames.length);
 					{/snippet}
 				</Toggle>
 
+				<Toggle
+					textClass="font-medium"
+					size="xs"
+					disabled={!$enterpriseLicense}
+					checked={flowStore.val.value.delete_after_secs != null}
+					on:change={() => {
+						if (flowStore.val.value.delete_after_secs != null) {
+							flowStore.val.value.delete_after_secs = undefined
+						} else {
+							flowStore.val.value.delete_after_secs = 0
+						}
+					}}
+					options={{
+						right: 'Delete all step results after completion',
+						rightTooltip: `When enabled, the logs, arguments and results of all flow steps will be deleted after the specified delay once the flow completes. Set to 0 for immediate deletion. The deletion is irreversible. ${!$enterpriseLicense ? 'This is a feature only available on enterprise edition.' : ''}`
+					}}
+					eeOnly={true}
+				/>
+				{#if flowStore.val.value.delete_after_secs != null}
+					<div class="ml-6 mt-1">
+						<SecondsInput
+							bind:seconds={flowStore.val.value.delete_after_secs}
+							disabled={!$enterpriseLicense}
+							size="sm"
+						/>
+					</div>
+				{/if}
+
 				<div>
 					<Toggle
 						textClass="font-medium"

package/package/components/flows/dfs.d.ts

@@ -1,4 +1,8 @@
 import type { FlowModule } from '../../gen';
-export declare function dfs<T>(modules: FlowModule[], f: (x: FlowModule, modules: FlowModule[], branches: FlowModule[][]) => T, opts?: {
+type FlowDfsOptions = {
     skipToolNodes?: boolean;
-}): T[];
+};
+type FlowModuleVisitor<T> = (x: FlowModule, modules: FlowModule[], branches: FlowModule[][]) => T;
+export declare function dfs<T>(modules: FlowModule[], f: FlowModuleVisitor<T>, opts?: FlowDfsOptions): T[];
+export declare function forEachFlowModule(modules: FlowModule[], f: FlowModuleVisitor<void>, opts?: FlowDfsOptions): void;
+export {};

package/package/components/flows/dfs.js

@@ -1,31 +1,39 @@
-export function dfs(modules, f, opts = {}) {
-    let result = [];
+function traverseFlowModules(modules, visit, opts = {}) {
     for (const module of modules) {
         if (module.value.type == 'forloopflow' || module.value.type == 'whileloopflow') {
-            result = result.concat(f(module, modules, [module.value.modules]));
-            result = result.concat(dfs(module.value.modules, f, opts));
+            visit(module, modules, [module.value.modules]);
+            traverseFlowModules(module.value.modules, visit, opts);
         }
         else if (module.value.type == 'branchone') {
             const allBranches = [module.value.default, ...module.value.branches.map((b) => b.modules)];
-            result = result.concat(f(module, modules, allBranches));
+            visit(module, modules, allBranches);
             for (const branch of allBranches) {
-                result = result.concat(dfs(branch, f, opts));
+                traverseFlowModules(branch, visit, opts);
             }
         }
         else if (module.value.type == 'branchall') {
             const allBranches = module.value.branches.map((b) => b.modules);
-            result = result.concat(f(module, modules, allBranches));
+            visit(module, modules, allBranches);
             for (const branch of allBranches) {
-                result = result.concat(dfs(branch, f, opts));
+                traverseFlowModules(branch, visit, opts);
             }
         }
         else if (module.value.type == 'aiagent' && !opts.skipToolNodes) {
-            result = result.concat(f(module, modules, [module.value.tools]));
-            result = result.concat(dfs(module.value.tools, f, opts));
+            visit(module, modules, [module.value.tools]);
+            traverseFlowModules(module.value.tools, visit, opts);
         }
         else {
-            result.push(f(module, modules, []));
+            visit(module, modules, []);
         }
     }
+}
+export function dfs(modules, f, opts = {}) {
+    let result = [];
+    traverseFlowModules(modules, (module, parentModules, branches) => {
+        result.push(f(module, parentModules, branches));
+    }, opts);
     return result;
 }
+export function forEachFlowModule(modules, f, opts = {}) {
+    traverseFlowModules(modules, f, opts);
+}

package/package/components/flows/flowDeleteController.d.ts

@@ -0,0 +1,32 @@
+import type { GroupDisplayState } from '../graph/groupEditor.svelte';
+import type { GroupedModulesProxy } from '../graph/groupedModulesProxy.svelte';
+import type { SelectionManager } from '../graph/selectionUtils.svelte';
+import type { FlowStructureNode } from '../graph/flowStructure';
+import type { OpenFlow } from '../../gen';
+import { type History } from '../../history.svelte';
+import type { StateStore } from '../../utils';
+import { type DeletePlan } from './flowDeleteUtils';
+import type { FlowState } from './flowState';
+export type PreparedDeleteRequest = {
+    plan: DeletePlan;
+    needsDependencyConfirmation: boolean;
+};
+export type DeletePlanExecutionContext = {
+    history?: History<OpenFlow>;
+    flowStore: StateStore<OpenFlow>;
+    flowStateStore: StateStore<FlowState>;
+    selectionManager: Pick<SelectionManager, 'clearSelection' | 'selectId'>;
+    onDelete?: (id: string) => void;
+};
+export type DeletePlanExecutionResult = {
+    removedStateIds: string[];
+    removedToolStateIds: string[];
+};
+export declare function prepareDeleteRequest(args: {
+    ids: string[];
+    flow: OpenFlow;
+    tree: FlowStructureNode[];
+    proxy: GroupedModulesProxy;
+    displayState: GroupDisplayState;
+}): PreparedDeleteRequest | undefined;
+export declare function executeDeletePlan(plan: DeletePlan, args: DeletePlanExecutionContext): DeletePlanExecutionResult;

package/package/components/flows/flowDeleteController.js

@@ -0,0 +1,54 @@
+import { push } from '../../history.svelte';
+import { refreshStateStore } from '../../svelte5Utils.svelte';
+import { createDeletePlan, removeDeletePlanTools } from './flowDeleteUtils';
+import { deleteFlowStateById } from './flowStateUtils.svelte';
+export function prepareDeleteRequest(args) {
+    const plan = createDeletePlan(args);
+    if (!plan) {
+        return undefined;
+    }
+    return {
+        plan,
+        needsDependencyConfirmation: Object.keys(plan.dependents).length > 0
+    };
+}
+export function executeDeletePlan(plan, args) {
+    push(args.history, args.flowStore.val);
+    const removedStructureStateIds = resolvePlannedStructureStateIds(plan.targets);
+    if (plan.selection.kind === 'clear') {
+        args.selectionManager.clearSelection();
+    }
+    else {
+        args.selectionManager.selectId(plan.selection.id);
+    }
+    if (plan.targets.some((target) => target.kind === 'preprocessor')) {
+        args.flowStore.val.value.preprocessor_module = undefined;
+    }
+    plan.structureDelete?.commit({ removeDuplicates: plan.removeDuplicates });
+    const removedToolStateIds = removeDeletePlanTools(plan.targets, args.flowStore.val.value.modules);
+    const removedStateIds = uniqueIds([...removedStructureStateIds, ...removedToolStateIds]);
+    for (const id of removedStateIds) {
+        deleteFlowStateById(id, args.flowStateStore);
+    }
+    refreshStateStore(args.flowStore);
+    if (plan.inputIds.length === 1) {
+        args.onDelete?.(plan.targets[0].id);
+    }
+    return {
+        removedStateIds,
+        removedToolStateIds
+    };
+}
+function resolvePlannedStructureStateIds(targets) {
+    const removedIds = [];
+    for (const target of targets) {
+        if (target.kind !== 'preprocessor' && target.kind !== 'structure_node') {
+            continue;
+        }
+        removedIds.push(...target.stateIds);
+    }
+    return uniqueIds(removedIds);
+}
+function uniqueIds(ids) {
+    return [...new Set(ids)];
+}

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

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

package/package/components/flows/flowDeleteController.test.js

@@ -0,0 +1,121 @@
+import { describe, expect, it, vi } from 'vitest';
+vi.mock('../aiProviderStorage', () => ({
+    loadStoredConfig: () => undefined
+}));
+vi.mock('./flowInfers', () => ({
+    AI_AGENT_SCHEMA: { properties: {} }
+}));
+import { GroupDisplayState } from '../graph/groupEditor.svelte';
+import { GroupedModulesProxy } from '../graph/groupedModulesProxy.svelte';
+import { executeDeletePlan, prepareDeleteRequest } from './flowDeleteController';
+function makeRawModule(id, expr) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'rawscript',
+            content: '',
+            language: 'python3',
+            input_transforms: expr
+                ? {
+                    user_input: {
+                        type: 'javascript',
+                        expr
+                    }
+                }
+                : {}
+        }
+    };
+}
+function makeAiAgent(id, tools) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+function makeFlowModuleTool(module) {
+    return {
+        id: module.id,
+        summary: module.summary,
+        value: {
+            tool_type: 'flowmodule',
+            ...module.value
+        }
+    };
+}
+describe('flowDeleteController', () => {
+    it('prepares confirmations and executes grouped ai-agent deletes end to end', () => {
+        const agent = makeAiAgent('agent_step', [
+            makeFlowModuleTool(makeRawModule('lookup_user')),
+            makeFlowModuleTool(makeAiAgent('support_agent', [makeFlowModuleTool(makeRawModule('create_ticket'))]))
+        ]);
+        const dependent = makeRawModule('dependent_step', 'results.create_ticket?.value');
+        const flowStore = {
+            val: {
+                summary: 'Flow',
+                value: {
+                    modules: [agent, dependent],
+                    groups: [
+                        {
+                            summary: 'Agent group',
+                            start_id: 'agent_step',
+                            end_id: 'agent_step'
+                        }
+                    ]
+                }
+            }
+        };
+        const proxy = new GroupedModulesProxy(flowStore);
+        const displayState = new GroupDisplayState(() => flowStore.val.value.groups ?? []);
+        const request = prepareDeleteRequest({
+            ids: ['agent_step'],
+            flow: flowStore.val,
+            tree: proxy.items,
+            proxy,
+            displayState
+        });
+        expect(request?.needsDependencyConfirmation).toBe(true);
+        expect(request?.plan.structureDelete?.affectedGroups).toHaveLength(1);
+        expect(request?.plan.structureDelete?.affectedGroups[0]).toMatchObject({
+            summary: 'Agent group',
+            start_id: 'agent_step',
+            end_id: 'agent_step'
+        });
+        const selectionManager = {
+            clearSelection: vi.fn(),
+            selectId: vi.fn()
+        };
+        const flowStateStore = {
+            val: {
+                agent_step: {},
+                lookup_user: {},
+                support_agent: {},
+                create_ticket: {},
+                dependent_step: {}
+            }
+        };
+        const onDelete = vi.fn();
+        const result = executeDeletePlan(request.plan, {
+            flowStore,
+            flowStateStore,
+            selectionManager,
+            onDelete
+        });
+        expect(result.removedStateIds).toEqual([
+            'agent_step',
+            'lookup_user',
+            'support_agent',
+            'create_ticket'
+        ]);
+        expect(flowStore.val.value.modules.map((module) => module.id)).toEqual(['dependent_step']);
+        expect(flowStore.val.value.groups ?? []).toEqual([]);
+        expect(Object.keys(flowStateStore.val)).toEqual(['dependent_step']);
+        expect(selectionManager.selectId).toHaveBeenCalledWith('dependent_step');
+        expect(onDelete).toHaveBeenCalledWith('agent_step');
+    });
+});

package/package/components/flows/flowDeleteUtils.d.ts

@@ -0,0 +1,48 @@
+import type { GroupDisplayState } from '../graph/groupEditor.svelte';
+import type { GroupedModulesProxy, PreparedStructureDelete } from '../graph/groupedModulesProxy.svelte';
+import { type FlowStructureNode } from '../graph/flowStructure';
+import type { FlowModule, OpenFlow } from '../../gen';
+import type { AgentTool } from './agentToolUtils';
+export type DeleteSelection = {
+    kind: 'clear';
+} | {
+    kind: 'select';
+    id: string;
+};
+type DeleteTargetBase = {
+    id: string;
+    stateIds: string[];
+};
+export type PreprocessorDeleteTarget = DeleteTargetBase & {
+    kind: 'preprocessor';
+};
+export type StructureDeleteTarget = DeleteTargetBase & {
+    kind: 'structure_node';
+};
+export type AgentToolDeleteTarget = DeleteTargetBase & {
+    kind: 'agent_tool';
+};
+export type DeleteTarget = PreprocessorDeleteTarget | StructureDeleteTarget | AgentToolDeleteTarget;
+export type DeletePlan = {
+    inputIds: string[];
+    targets: DeleteTarget[];
+    plannedStateIds: string[];
+    dependents: Record<string, string[]>;
+    selection: DeleteSelection;
+    structureDelete?: PreparedStructureDelete;
+    removeDuplicates: boolean;
+};
+export type ResolvedDeleteTargets = {
+    targets: DeleteTarget[];
+    missingIds: string[];
+};
+export declare function resolveDeleteTargets(tree: FlowStructureNode[], modules: FlowModule[], ids: string[], hasPreprocessor: boolean): ResolvedDeleteTargets;
+export declare function createDeletePlan(args: {
+    ids: string[];
+    flow: OpenFlow;
+    tree: FlowStructureNode[];
+    proxy: GroupedModulesProxy;
+    displayState: GroupDisplayState;
+}): DeletePlan | undefined;
+export declare function removeDeletePlanTools(targets: DeleteTarget[], modules: FlowModule[], onRemove?: (tool: AgentTool) => void): string[];
+export {};