windmill-components 1.532.0 → 1.542.4

package/package/components/copilot/chat/flow/FlowAIChat.svelte

@@ -9,7 +9,7 @@ import { loadSchemaFromModule } from '../../../flows/flowInfers';
 import { aiChatManager } from '../AIChatManager.svelte';
 import { refreshStateStore } from '../../../../svelte5Utils.svelte';
 import DiffDrawer from '../../../DiffDrawer.svelte';
-let { flowModuleSchemaMap, } = $props();
+let { flowModuleSchemaMap } = $props();
 const { flowStore, flowStateStore, selectedId, currentEditor } = getContext('FlowEditorContext');
 const { exprsToSet } = getContext('FlowCopilotContext') ?? {};
 let affectedModules = $state({});
@@ -71,13 +71,10 @@ const flowHelpers = {
     hasDiff: () => {
         return Object.keys(affectedModules).length > 0;
     },
-    acceptAllModuleActions: () => {
-        for (const [id, affectedModule] of Object.entries(affectedModules)) {
-            if (affectedModule.action === 'removed') {
-                deleteStep(id);
-            }
+    acceptAllModuleActions() {
+        for (const id of Object.keys(affectedModules)) {
+            this.acceptModuleAction(id);
         }
-        affectedModules = {};
     },
     rejectAllModuleActions() {
         for (const id of Object.keys(affectedModules)) {
@@ -151,7 +148,18 @@ const flowHelpers = {
                     if (!newModule) {
                         throw new Error('Module not found');
                     }
-                    newModule.value = oldModule.value;
+                    // Apply the old code to the editor and hide diff editor if the reverted module is a rawscript
+                    if (newModule.value.type === 'rawscript' &&
+                        $currentEditor?.type === 'script' &&
+                        $currentEditor.stepId === id) {
+                        const aiChatEditorHandler = $currentEditor.editor.getAiChatEditorHandler();
+                        if (aiChatEditorHandler) {
+                            aiChatEditorHandler.revertAll({ disableReviewCallback: true });
+                            $currentEditor.hideDiffMode();
+                        }
+                    }
+                    Object.keys(newModule).forEach((k) => delete newModule[k]);
+                    Object.assign(newModule, $state.snapshot(oldModule));
                 }
                 refreshStateStore(flowStore);
                 delete affectedModules[id];
@@ -162,6 +170,15 @@ const flowHelpers = {
         if (affectedModules[id]?.action === 'removed') {
             deleteStep(id);
         }
+        if (affectedModules[id]?.action === 'modified' &&
+            $currentEditor &&
+            $currentEditor.type === 'script' &&
+            $currentEditor.stepId === id) {
+            const aiChatEditorHandler = $currentEditor.editor.getAiChatEditorHandler();
+            if (aiChatEditorHandler) {
+                aiChatEditorHandler.keepAll({ disableReviewCallback: true });
+            }
+        }
         delete affectedModules[id];
     },
     // ai chat tools
@@ -416,6 +433,72 @@ const flowHelpers = {
             refreshStateStore(flowStore);
         }
         setModuleStatus(id, 'modified');
+    },
+    setForLoopOptions: async (id, opts) => {
+        const module = getModule(id);
+        if (!module) {
+            throw new Error('Module not found');
+        }
+        if (module.value.type !== 'forloopflow') {
+            throw new Error('Module is not a forloopflow');
+        }
+        // Apply skip_failures if provided
+        if (typeof opts.skip_failures === 'boolean') {
+            module.value.skip_failures = opts.skip_failures;
+        }
+        // Apply parallel if provided
+        if (typeof opts.parallel === 'boolean') {
+            module.value.parallel = opts.parallel;
+        }
+        // Handle parallelism
+        if (opts.parallel === false) {
+            // If parallel is disabled, clear parallelism
+            module.value.parallelism = undefined;
+        }
+        else if (opts.parallelism !== undefined) {
+            if (opts.parallelism === null) {
+                // Explicitly clear parallelism
+                module.value.parallelism = undefined;
+            }
+            else if (module.value.parallel || opts.parallel === true) {
+                // Only set parallelism if parallel is enabled
+                const n = Math.max(1, Math.floor(Math.abs(opts.parallelism)));
+                module.value.parallelism = n;
+            }
+        }
+        refreshStateStore(flowStore);
+        setModuleStatus(id, 'modified');
+    },
+    setModuleControlOptions: async (id, opts) => {
+        const module = getModule(id);
+        if (!module) {
+            throw new Error('Module not found');
+        }
+        // Handle stop_after_if
+        if (typeof opts.stop_after_if === 'boolean') {
+            if (opts.stop_after_if === false) {
+                module.stop_after_if = undefined;
+            }
+            else {
+                module.stop_after_if = {
+                    expr: opts.stop_after_if_expr ?? '',
+                    skip_if_stopped: opts.stop_after_if
+                };
+            }
+        }
+        // Handle skip_if
+        if (typeof opts.skip_if === 'boolean') {
+            if (opts.skip_if === false) {
+                module.skip_if = undefined;
+            }
+            else {
+                module.skip_if = {
+                    expr: opts.skip_if_expr ?? ''
+                };
+            }
+        }
+        refreshStateStore(flowStore);
+        setModuleStatus(id, 'modified');
     }
 };
 function deleteStep(id) {
@@ -454,6 +537,25 @@ $effect(() => {
     const cleanup = aiChatManager.listenForCurrentEditorChanges($currentEditor);
     return cleanup;
 });
+// Automatically show revert review when selecting a rawscript module with pending changes
+$effect(() => {
+    if ($currentEditor?.type === 'script' &&
+        $selectedId &&
+        affectedModules[$selectedId] &&
+        $currentEditor.editor.getAiChatEditorHandler()) {
+        const moduleLastSnapshot = getModule($selectedId, lastSnapshot);
+        const content = moduleLastSnapshot?.value.type === 'rawscript' ? moduleLastSnapshot.value.content : '';
+        if (content.length > 0) {
+            untrack(() => $currentEditor.editor.reviewAppliedCode(content, {
+                onFinishedReview: () => {
+                    const id = $selectedId;
+                    flowHelpers.acceptModuleAction(id);
+                    $currentEditor.hideDiffMode();
+                }
+            }));
+        }
+    }
+});
 let diffDrawer = $state(undefined);
 </script>
 

package/package/components/copilot/chat/flow/core.d.ts

@@ -33,6 +33,17 @@ export interface FlowAIChatHelpers {
     addBranch: (id: string) => Promise<void>;
     removeBranch: (id: string, branchIndex: number) => Promise<void>;
     setForLoopIteratorExpression: (id: string, expression: string) => Promise<void>;
+    setForLoopOptions: (id: string, opts: {
+        skip_failures?: boolean | null;
+        parallel?: boolean | null;
+        parallelism?: number | null;
+    }) => Promise<void>;
+    setModuleControlOptions: (id: string, opts: {
+        stop_after_if?: boolean | null;
+        stop_after_if_expr?: string | null;
+        skip_if?: boolean | null;
+        skip_if_expr?: string | null;
+    }) => Promise<void>;
     setCode: (id: string, code: string) => Promise<void>;
 }
 declare const newStepSchema: z.ZodUnion<[z.ZodObject<{
@@ -127,7 +138,7 @@ declare const insertLocationSchema: z.ZodUnion<[z.ZodObject<{
 }>]>;
 type InsertLocation = z.infer<typeof insertLocationSchema>;
 export declare const flowTools: Tool<FlowAIChatHelpers>[];
-export declare function prepareFlowSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareFlowSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;
 export declare function prepareFlowUserMessage(instructions: string, flowAndSelectedId?: {
     flow: ExtendedOpenFlow;
     selectedId: string;

package/package/components/copilot/chat/flow/core.js

@@ -1,4 +1,5 @@
 import { ScriptService, JobService } from '../../../../gen';
+import { emitUiIntent } from './uiIntents';
 import YAML from 'yaml';
 import { z } from 'zod';
 import uFuzzy from '@leeoniya/ufuzzy';
@@ -98,6 +99,51 @@ const setForLoopIteratorExpressionSchema = z.object({
     expression: z.string().describe('The JavaScript expression to set for the iterator')
 });
 const setForLoopIteratorExpressionToolDef = createToolDef(setForLoopIteratorExpressionSchema, 'set_forloop_iterator_expression', 'Set the iterator JavaScript expression for the given forloop step');
+const setForLoopOptionsSchema = z.object({
+    id: z.string().describe('The id of the forloop step to configure'),
+    skip_failures: z
+        .boolean()
+        .nullable()
+        .optional()
+        .describe('Whether to skip failures in the loop (null to not change)'),
+    parallel: z
+        .boolean()
+        .nullable()
+        .optional()
+        .describe('Whether to run iterations in parallel (null to not change)'),
+    parallelism: z
+        .number()
+        .int()
+        .min(1)
+        .nullable()
+        .optional()
+        .describe('Maximum number of parallel iterations (null to not change)')
+});
+const setForLoopOptionsToolDef = createToolDef(setForLoopOptionsSchema, 'set_forloop_options', 'Set advanced options for a forloop step: skip_failures, parallel, and parallelism');
+const setModuleControlOptionsSchema = z.object({
+    id: z.string().describe('The id of the module to configure'),
+    stop_after_if: z
+        .boolean()
+        .nullable()
+        .optional()
+        .describe('Early stop condition (true to set, false to clear, null to not change)'),
+    stop_after_if_expr: z
+        .string()
+        .nullable()
+        .optional()
+        .describe('JavaScript expression for early stop condition. Can use `flow_input` or `result`. `result` is the result of the step. `results.<step_id>` is not supported, do not use it. Only used if stop_after_if is true. Example: `flow_input.x > 10` or `result === "failure"`'),
+    skip_if: z
+        .boolean()
+        .nullable()
+        .optional()
+        .describe('Skip condition (true to set, false to clear, null to not change)'),
+    skip_if_expr: z
+        .string()
+        .nullable()
+        .optional()
+        .describe('JavaScript expression for skip condition. Can use `flow_input` or `results.<step_id>`. Only used if skip_if is true. Example: `flow_input.x > 10` or `results.a === "failure"`')
+});
+const setModuleControlOptionsToolDef = createToolDef(setModuleControlOptionsSchema, 'set_module_control_options', 'Set control options for any module: stop_after_if (early stop) and skip_if (conditional skip)');
 const setBranchPredicateSchema = z.object({
     id: z.string().describe('The id of the branchone step to set the predicates for'),
     branchIndex: z
@@ -378,6 +424,70 @@ export const flowTools = [
             return `Forloop '${parsedArgs.id}' iterator expression set`;
         }
     },
+    {
+        def: {
+            ...setForLoopOptionsToolDef,
+            function: { ...setForLoopOptionsToolDef.function, strict: false }
+        },
+        fn: async ({ args, helpers, toolId, toolCallbacks }) => {
+            const parsedArgs = setForLoopOptionsSchema.parse(args);
+            await helpers.setForLoopOptions(parsedArgs.id, {
+                skip_failures: parsedArgs.skip_failures,
+                parallel: parsedArgs.parallel,
+                parallelism: parsedArgs.parallelism
+            });
+            helpers.selectStep(parsedArgs.id);
+            const message = `Set forloop '${parsedArgs.id}' options`;
+            toolCallbacks.setToolStatus(toolId, {
+                content: message
+            });
+            return `${message}: ${JSON.stringify(parsedArgs)}`;
+        }
+    },
+    {
+        def: {
+            ...setModuleControlOptionsToolDef,
+            function: { ...setModuleControlOptionsToolDef.function, strict: false }
+        },
+        fn: async ({ args, helpers, toolId, toolCallbacks }) => {
+            const parsedArgs = setModuleControlOptionsSchema.parse(args);
+            await helpers.setModuleControlOptions(parsedArgs.id, {
+                stop_after_if: parsedArgs.stop_after_if,
+                stop_after_if_expr: parsedArgs.stop_after_if_expr,
+                skip_if: parsedArgs.skip_if,
+                skip_if_expr: parsedArgs.skip_if_expr
+            });
+            helpers.selectStep(parsedArgs.id);
+            // Emit UI intent to show early-stop tab when stop_after_if is configured
+            const modules = helpers.getModules();
+            const module = findModuleById(modules, parsedArgs.id);
+            if (!module) {
+                throw new Error(`Module with id '${parsedArgs.id}' not found in flow.`);
+            }
+            const moduleType = module?.value.type;
+            const hasSpecificComponents = ['forloopflow', 'whileloopflow', 'branchall', 'branchone'];
+            const prefix = hasSpecificComponents.includes(moduleType) ? `${moduleType}` : 'flow';
+            if (typeof parsedArgs.stop_after_if === 'boolean') {
+                emitUiIntent({
+                    kind: 'open_module_tab',
+                    componentId: `${prefix}-${parsedArgs.id}`,
+                    tab: 'early-stop'
+                });
+            }
+            if (typeof parsedArgs.skip_if === 'boolean') {
+                emitUiIntent({
+                    kind: 'open_module_tab',
+                    componentId: `${prefix}-${parsedArgs.id}`,
+                    tab: 'skip'
+                });
+            }
+            const message = `Set module '${parsedArgs.id}' control options`;
+            toolCallbacks.setToolStatus(toolId, {
+                content: message
+            });
+            return `${message}: ${JSON.stringify(parsedArgs)}`;
+        }
+    },
     {
         def: resourceTypeToolDef,
         fn: async ({ args, toolId, workspace, toolCallbacks }) => {
@@ -532,8 +642,8 @@ export const flowTools = [
         showDetails: true
     }
 ];
-export function prepareFlowSystemMessage() {
-    const content = `You are a helpful assistant that creates and edits workflows on the Windmill platform. You're provided with a bunch of tools to help you edit the flow.
+export function prepareFlowSystemMessage(customPrompt) {
+    let content = `You are a helpful assistant that creates and edits workflows on the Windmill platform. You're provided with a bunch of tools to help you edit the flow.
 Follow the user instructions carefully.
 Go step by step, and explain what you're doing as you're doing it.
 DO NOT wait for user confirmation before performing an action. Only do it if the user explicitly asks you to wait in their initial instructions.
@@ -584,10 +694,17 @@ When creating new steps, follow this process for EACH step:
 
 ### Special Step Types
 For special step types, follow these additional steps:
-- For forloop steps: Set the iterator expression using set_forloop_iterator_expression
+- For forloop steps: 
+  - Set the iterator expression using set_forloop_iterator_expression
+  - Set advanced options (parallel, parallelism, skip_failures) using set_forloop_options
 - For branchone steps: Set the predicates for each branch using set_branch_predicate
 - For branchall steps: No additional setup needed
 
+### Module Control Options
+For any module type, you can set control flow options using set_module_control_options:
+- **stop_after_if**: Early stop condition - stops the module if expression evaluates to true. Can use "flow_input" or "result". "result" is the result of the step. "results.<step_id>" is not supported, do not use it. Example: "flow_input.x > 10" or "result === "failure""
+- **skip_if**: Skip condition - skips the module entirely if expression evaluates to true. Can use "flow_input" or "results.<step_id>". Example: "flow_input.x > 10" or "results.a === "failure""
+
 ### Step Insertion Rules
 When adding steps, carefully consider the execution order:
 1. Steps are executed in the order they appear in the flow definition, not in the order they were added
@@ -608,6 +725,7 @@ When adding steps, carefully consider the execution order:
 ### JavaScript Expressions
 For step inputs, forloop iterator expressions and branch predicates, use JavaScript expressions with these variables:
 - Step results: results.stepid or results.stepid.property_name
+- Break condition (stop_after_if) in for loops: result (contains the result of the last iteration)
 - Loop iterator: flow_input.iter.value (inside loops)
 - Flow inputs: flow_input.property_name
 - Static values: Use JavaScript syntax (e.g., "hello", true, 3)
@@ -616,6 +734,12 @@ Note: These variables are only accessible in step inputs, forloop iterator expre
 
 For truly static values in step inputs (those not linked to previous steps or loop iterations), prefer using flow inputs by default unless explicitly specified otherwise. This makes the flow more configurable and reusable. For example, instead of hardcoding an email address in a step input, create a flow input for it.
 
+### For Loop Advanced Options
+When configuring for-loop steps, consider these options:
+- **parallel: true** - Run iterations in parallel for independent operations (significantly faster for I/O bound tasks)
+- **parallelism: N** - Limit concurrent iterations (only applies when parallel=true). Use to prevent overwhelming external APIs
+- **skip_failures: true** - Continue processing remaining iterations even if some fail. Failed iterations return error objects as results
+
 ### Special Modules
 - Preprocessor: Runs before the first step when triggered externally
   - ID: 'preprocessor'
@@ -644,12 +768,16 @@ On Windmill, credentials and configuration are stored in resources. Resource typ
 If the user needs a resource as flow input, you should set the property type in the schema to "object" as well as add a key called "format" and set it to "resource-nameofresourcetype" (e.g. "resource-stripe").
 If the user wants a specific resource as step input, you should set the step value to a static string in the following format: "$res:path/to/resource".
 `;
+    // If there's a custom prompt, append it to the system prompt
+    if (customPrompt?.trim()) {
+        content = `${content}\n\nUSER GIVEN INSTRUCTIONS:\n${customPrompt.trim()}`;
+    }
     return {
         role: 'system',
         content
     };
 }
-export function prepareFlowUserMessage(instructions, flowAndSelectedId, selectedContext) {
+export function prepareFlowUserMessage(instructions, flowAndSelectedId, selectedContext = []) {
     const flow = flowAndSelectedId?.flow;
     const selectedId = flowAndSelectedId?.selectedId;
     // Handle context elements
@@ -662,7 +790,7 @@ ${instructions}`;
             content: userMessage
         };
     }
-    const codePieces = selectedContext?.filter((c) => c.type === 'code_piece') ?? [];
+    const codePieces = selectedContext.filter((c) => c.type === 'flow_module_code_piece');
     const flowModulesYaml = applyCodePiecesToFlowModules(codePieces, flow.value.modules);
     let flowContent = `## FLOW:
 flow_input schema:

package/package/components/copilot/chat/flow/uiIntents.d.ts

@@ -0,0 +1,8 @@
+import { type Writable } from 'svelte/store';
+export type UiIntent = {
+    kind: 'open_module_tab';
+    componentId: string;
+    tab: string;
+};
+export declare const uiIntentStore: Writable<UiIntent | null>;
+export declare function emitUiIntent(intent: UiIntent): void;

package/package/components/copilot/chat/flow/uiIntents.js

@@ -0,0 +1,5 @@
+import { writable } from 'svelte/store';
+export const uiIntentStore = writable(null);
+export function emitUiIntent(intent) {
+    uiIntentStore.set(intent);
+}

package/package/components/copilot/chat/flow/useUiIntent.d.ts

@@ -0,0 +1,5 @@
+type Handlers = {
+    openTab?: (tab: string) => void;
+};
+export declare function useUiIntent(componentId: string, handlers: Handlers): void;
+export {};

package/package/components/copilot/chat/flow/useUiIntent.js

@@ -0,0 +1,12 @@
+import { uiIntentStore } from './uiIntents';
+import { onDestroy } from 'svelte';
+export function useUiIntent(componentId, handlers) {
+    const unsub = uiIntentStore.subscribe((intent) => {
+        if (!intent || intent.componentId !== componentId)
+            return;
+        if (intent.kind === 'open_module_tab')
+            handlers.openTab?.(intent.tab);
+        uiIntentStore.set(null);
+    });
+    onDestroy(() => unsub());
+}

package/package/components/copilot/chat/monaco-adapter.d.ts

@@ -5,6 +5,11 @@ type ExcludeVariant<T, K extends keyof T, V> = T extends Record<K, V> ? never :
 type VisualChangeWithDiffIndex = ExcludeVariant<VisualChange, 'type', 'added_inline'> & {
     diffIndex: number;
 };
+export interface ReviewChangesOpts {
+    applyAll?: boolean;
+    mode?: 'apply' | 'revert';
+    onFinishedReview?: () => void;
+}
 export declare class AIChatEditorHandler {
     editor: meditor.IStandaloneCodeEditor;
     viewZoneIds: string[];
@@ -15,18 +20,32 @@ export declare class AIChatEditorHandler {
         changes: VisualChangeWithDiffIndex[];
         groupIndex: number;
     }[];
+    private reviewState;
     constructor(editor: meditor.IStandaloneCodeEditor);
     clear(): void;
     preventWriting(): void;
     allowWriting(): void;
-    finish(): Promise<void>;
-    acceptAll(): Promise<void>;
-    rejectAll(): Promise<void>;
+    finish(opts?: {
+        disableReviewCallback?: boolean;
+    }): Promise<void>;
+    getReviewMode(): 'apply' | 'revert' | null;
+    acceptAll(opts?: {
+        disableReviewCallback?: boolean;
+    }): Promise<void>;
+    rejectAll(opts?: {
+        disableReviewCallback?: boolean;
+    }): Promise<void>;
+    keepAll(opts?: {
+        disableReviewCallback?: boolean;
+    }): Promise<void>;
+    revertAll(opts?: {
+        disableReviewCallback?: boolean;
+    }): Promise<void>;
     applyGroup(group: {
         changes: VisualChangeWithDiffIndex[];
         groupIndex: number;
     }): void;
     private calculateVisualChanges;
-    reviewAndApply(newCode: string, applyAll?: boolean): Promise<void>;
+    reviewChanges(targetCode: string, opts?: ReviewChangesOpts): Promise<void>;
 }
 export {};

package/package/components/copilot/chat/monaco-adapter.js

@@ -10,6 +10,8 @@ export class AIChatEditorHandler {
     readOnlyDisposable = undefined;
     reviewingChanges = writable(false);
     groupChanges = [];
+    // Track review decisions
+    reviewState = null;
     constructor(editor) {
         this.editor = editor;
     }
@@ -48,7 +50,14 @@ export class AIChatEditorHandler {
             this.readOnlyDisposable.dispose();
         }
     }
-    async finish() {
+    async finish(opts) {
+        // expose mode getter relies on reviewState
+        // Call completion callback if we're tracking review state
+        if (this.reviewState?.onFinishedReview && !opts?.disableReviewCallback) {
+            this.reviewState.onFinishedReview();
+        }
+        // Reset review state
+        this.reviewState = null;
         this.clear();
         this.allowWriting();
         this.reviewingChanges.set(false);
@@ -56,15 +65,26 @@ export class AIChatEditorHandler {
             scrollBeyondLastLine: false
         });
     }
-    async acceptAll() {
+    getReviewMode() {
+        return this.reviewState?.mode ?? null;
+    }
+    async acceptAll(opts) {
         this.groupChanges.reverse();
         for (const group of this.groupChanges) {
             this.applyGroup(group);
         }
-        this.finish();
+        this.finish(opts);
+    }
+    async rejectAll(opts) {
+        this.finish(opts);
+    }
+    // Keep all changes, used in revert mode
+    async keepAll(opts) {
+        this.finish(opts);
     }
-    async rejectAll() {
-        this.finish();
+    // Revert all changes, used in revert mode
+    async revertAll(opts) {
+        this.acceptAll(opts);
     }
     applyGroup(group) {
         // maximum of 2 changes per group with the deletion first
@@ -147,23 +167,30 @@ export class AIChatEditorHandler {
         }
         return changedLines;
     }
-    async reviewAndApply(newCode, applyAll = false) {
-        if (aiChatManager.pendingNewCode === newCode) {
+    async reviewChanges(targetCode, opts) {
+        if (aiChatManager.pendingNewCode === targetCode && opts?.mode === 'apply') {
             this.acceptAll();
             return;
         }
         else if (aiChatManager.pendingNewCode) {
             this.clear();
         }
-        aiChatManager.pendingNewCode = newCode;
-        const changedLines = await this.calculateVisualChanges(newCode);
+        aiChatManager.pendingNewCode = targetCode;
+        const changedLines = await this.calculateVisualChanges(targetCode);
         if (changedLines.length === 0)
             return;
+        // Initialize review state for tracking
+        this.reviewState = {
+            mode: opts?.mode ?? 'apply',
+            onFinishedReview: opts?.onFinishedReview
+        };
         let indicesOfRejectedLineChanges = [];
         for (const [groupIndex, group] of this.groupChanges.entries()) {
             let collection = undefined;
             let ids = [];
-            const acceptFn = () => {
+            const isRevert = opts?.mode === 'revert';
+            // Apply this group and continue with remaining changes
+            const onApply = () => {
                 this.applyGroup(group);
                 this.clear();
                 let newCodeWithRejects = '';
@@ -178,9 +205,11 @@ export class AIChatEditorHandler {
                         newCodeWithRejects += change.value;
                     }
                 }
-                this.reviewAndApply(newCodeWithRejects);
+                this.reviewChanges(newCodeWithRejects, opts);
             };
-            const rejectFn = () => {
+            // Discard this group and continue with remaining changes
+            const onDiscard = () => {
+                // This group was not applied (not reverted in revert mode)
                 indicesOfRejectedLineChanges.push(...group.changes.map((c) => c.diffIndex));
                 collection?.clear();
                 this.editor.changeViewZones((acc) => {
@@ -193,25 +222,35 @@ export class AIChatEditorHandler {
                     this.finish();
                 }
             };
+            // In revert mode: Accept = keep current code, Reject = revert to targetCode
+            // In apply mode: Accept = apply changes, Reject = discard changes
+            const acceptFn = isRevert ? onDiscard : onApply;
+            const rejectFn = isRevert ? onApply : onDiscard;
             const changes = group.changes.map((c, i) => {
                 if (i === group.changes.length - 1) {
                     return {
                         ...c,
-                        options: { ...(c.options ?? {}), review: { acceptFn, rejectFn } }
+                        options: {
+                            ...(c.options ?? {}),
+                            review: {
+                                acceptFn,
+                                rejectFn
+                            }
+                        }
                     };
                 }
                 else {
                     return c;
                 }
             });
-            if (!applyAll) {
+            if (!opts?.applyAll) {
                 ;
-                ({ collection, ids } = await displayVisualChanges('editor-windmill-chat-style', this.editor, changes));
+                ({ collection, ids } = await displayVisualChanges('editor-windmill-chat-style', this.editor, changes, isRevert));
                 this.decorationsCollections.push(collection);
                 this.viewZoneIds.push(...ids);
             }
         }
-        if (applyAll) {
+        if (opts?.applyAll) {
             this.acceptAll();
         }
     }

package/package/components/copilot/chat/navigator/core.d.ts

@@ -3,5 +3,5 @@ import type { Tool } from '../shared';
 export declare const CHAT_SYSTEM_PROMPT = "\nYou are Windmill's intelligent assistant, designed to help users navigate the application and answer questions about its functionality. It is your only purpose to help the user in the context of the windmill application.\nWindmill is an open-source developer platform for building internal tools, API integrations, background jobs, workflows, and user interfaces. It offers a unified system where scripts are automatically turned into sharable UIs and can be composed into flows or embedded in custom applications.\n\nYou have access to these tools:\n1. View current buttons and inputs on the page (get_triggerable_components)\n2. Execute buttons and inputs (trigger_component) \n3. Get documentation for user requests (get_documentation)\n4. Change the AI mode to the one specified (change_mode)\n\nINSTRUCTIONS:\n- When users ask about application features or concepts, first use get_documentation internally to retrieve accurate information about how to fulfill the user's request.\n- Then immediately use the available tools to guide the user through the application. Do not wait for the user's confirmation before taking action.\n- If you detect a confirmation modal that needs user confirmation, stop the navigation and let the user know that the action is pending confirmation.\n- Use get_triggerable_components to understand available options, and then trigger the components using trigger_component. Then wait a moment before rescanning the current page, and then continue with the next step. Do this 5 times max.\n- Make sure you navigated as far as possible before responding to the user. Always use get_triggerable_components one last time to make sure you didn't miss anything.\n- If you are not able to fulfill the user's request after 5 attempts, redirect the user to the documentation.\n- If you are asked to fill a form or act on an input, input the existing json object and change the fields the user asked you to change. Take into account the prompt_for_ai field of the schema to know what and how to do changes. Then tell the user that you have updated the form, and ask him to review the changes before running the script or flow.\n- For form inputs where format starts with \"resource-\" and is not \"resource-obj\", fetch the available resources using get_available_resources, and then use the resource_path prefixed with \"$res:\" to fill the input.\n- If you are not sure about an input, set the ones you are sure about, and then ask the user for the value of the input you are not sure about.\n- If the user asks you to make an API call, switch to API mode with the change_mode tool before using the new tools you'll have access to to make the API call.\n\nGENERAL PRINCIPLES:\n- Be concise but thorough\n- Focus on taking action and completing the user's goals\n- Maintain a friendly, professional tone\n- If you encounter an error or can't complete a request, explain why and suggest alternatives\n- When asked about a specific script, flow or app, first check components directly related to the mentioned entity, before checking the other components.\n- When you do not find what you are looking for on the current page, go to the home page by looking for the \"Home\" component, then scan the components again.\n\nIMPORTANT CONSIDERATIONS:\n- The user might have changed the page in the middle of the conversation, so make sure you rescan the page on each user request instead of just responding that you cannot find what the user is asking for.\n- If you navigate to a script creation page, consider this:\n  - The page opens with the settings drawer open. After doing the changes mentioned by the user, close the settings drawer.\n  - Then if the user has described what he wanted the script to do, switch to script mode with the change_mode tool, and use the new tools you'll have access to to edit the script.\n- If you navigate to a flow creation page, consider this:\n  - If the user has described what he wanted the flow to do, switch to flow mode with the change_mode tool before using the new tools you'll have access to to edit the flow.\n\nAlways use the provided tools purposefully and appropriately to achieve the user's goals.\nYour actions only allow you to navigate the application through the provided tools.\nWhen you complete the user's request, do not say \"I created...\" or \"I updated...\" or \"I deleted...\", but rather complete your response with precisions about how it works based on the documentation. Also drop a link to the relevant documentation if possible.\n\nExample of good behavior:\n- User: \"How can I set my AI providers?\"\n- You: <call get_documentation and fetch relevant documentation>\n- You: <call get_triggerable_components to find relevant components>\n- You: <trigger the components>\n- You: \"<precisions about the request based on the documentation>\"\n";
 export declare const getDocumentationTool: Tool<{}>;
 export declare const navigatorTools: Tool<{}>[];
-export declare function prepareNavigatorSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareNavigatorSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;
 export declare function prepareNavigatorUserMessage(instructions: string): ChatCompletionUserMessageParam;

package/package/components/copilot/chat/navigator/core.js

@@ -319,10 +319,15 @@ export const navigatorTools = [
     getCurrentPageNameTool,
     getAvailableResourcesTool
 ];
-export function prepareNavigatorSystemMessage() {
+export function prepareNavigatorSystemMessage(customPrompt) {
+    let content = CHAT_SYSTEM_PROMPT;
+    // If there's a custom prompt, append it to the system prompt
+    if (customPrompt?.trim()) {
+        content = `${content}\n\nUSER GIVEN INSTRUCTIONS:\n${customPrompt.trim()}`;
+    }
     return {
         role: 'system',
-        content: CHAT_SYSTEM_PROMPT
+        content
     };
 }
 export function prepareNavigatorUserMessage(instructions) {