windmill-components 1.537.1 → 1.542.5

package/package/components/copilot/chat/anthropic.js

@@ -0,0 +1,208 @@
+import { OpenAI } from 'openai';
+import { getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
+import { processToolCall } from './shared';
+export async function getAnthropicCompletion(messages, abortController, tools) {
+    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true });
+    const { system, messages: anthropicMessages } = convertOpenAIToAnthropicMessages(messages);
+    const anthropicTools = convertOpenAIToolsToAnthropic(tools);
+    const anthropicClient = workspaceAIClients.getAnthropicClient();
+    const anthropicParams = {
+        model: config.model,
+        max_tokens: config.max_tokens,
+        messages: anthropicMessages,
+        ...(system && { system }),
+        ...(anthropicTools && { tools: anthropicTools }),
+        ...(typeof config.temperature === 'number' && { temperature: config.temperature })
+    };
+    const stream = anthropicClient.messages.stream(anthropicParams, {
+        signal: abortController.signal,
+        headers: {
+            'X-Provider': provider,
+            'anthropic-version': '2023-06-01',
+            'X-Anthropic-SDK': 'true'
+        }
+    });
+    return stream;
+}
+export async function parseAnthropicCompletion(completion, callbacks, messages, addedMessages, tools, helpers) {
+    let toolCallsToProcess = [];
+    let error = null;
+    // Handle text streaming
+    completion.on('text', (textDelta, _textSnapshot) => {
+        callbacks.onNewToken(textDelta);
+    });
+    completion.on('message', (message) => {
+        for (const block of message.content) {
+            if (block.type === 'text') {
+                const text = block.text;
+                const assistantMessage = { role: 'assistant', content: text };
+                messages.push(assistantMessage);
+                addedMessages.push(assistantMessage);
+                callbacks.onMessageEnd();
+            }
+            else if (block.type === 'tool_use') {
+                // Convert Anthropic tool calls to OpenAI format for compatibility
+                toolCallsToProcess.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input)
+                    }
+                });
+                // Preprocess tool if it has a preAction
+                const tool = tools.find((t) => t.def.function.name === block.name);
+                if (tool && tool.preAction) {
+                    tool.preAction({ toolCallbacks: callbacks, toolId: block.id });
+                }
+            }
+        }
+    });
+    // Handle errors
+    completion.on('error', (e) => {
+        console.error('Anthropic stream error:', e);
+        error = e;
+    });
+    // Wait for completion
+    await completion.done();
+    callbacks.onMessageEnd();
+    if (error) {
+        throw error;
+    }
+    // Process tool calls if any
+    if (toolCallsToProcess.length > 0) {
+        const assistantWithTools = {
+            role: 'assistant',
+            tool_calls: toolCallsToProcess
+        };
+        messages.push(assistantWithTools);
+        addedMessages.push(assistantWithTools);
+        // Process each tool call
+        for (const toolCall of toolCallsToProcess) {
+            const messageToAdd = await processToolCall({
+                tools,
+                toolCall,
+                helpers,
+                toolCallbacks: callbacks
+            });
+            messages.push(messageToAdd);
+            addedMessages.push(messageToAdd);
+        }
+        return true; // Continue the conversation loop
+    }
+    return false; // End the conversation
+}
+export function convertOpenAIToAnthropicMessages(messages) {
+    let system;
+    const anthropicMessages = [];
+    for (const message of messages) {
+        if (message.role === 'system') {
+            const systemText = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+            // Convert system to array format with cache_control for caching
+            system = [
+                {
+                    type: 'text',
+                    text: systemText,
+                    cache_control: { type: 'ephemeral' }
+                }
+            ];
+            continue;
+        }
+        if (message.role === 'user') {
+            anthropicMessages.push({
+                role: 'user',
+                content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
+            });
+        }
+        else if (message.role === 'assistant') {
+            const content = [];
+            if (message.content) {
+                content.push({
+                    type: 'text',
+                    text: typeof message.content === 'string' ? message.content : JSON.stringify(message.content)
+                });
+            }
+            if (message.tool_calls) {
+                for (const toolCall of message.tool_calls) {
+                    if (toolCall.type !== 'function')
+                        continue;
+                    let input = {};
+                    try {
+                        input = JSON.parse(toolCall.function.arguments || '{}');
+                    }
+                    catch (e) {
+                        console.error('Failed to parse tool call arguments', e);
+                    }
+                    content.push({
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.function.name,
+                        input
+                    });
+                }
+            }
+            if (content.length > 0) {
+                anthropicMessages.push({
+                    role: 'assistant',
+                    content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+                });
+            }
+        }
+        else if (message.role === 'tool') {
+            // Tool results must be in user messages in Anthropic format
+            anthropicMessages.push({
+                role: 'user',
+                content: [
+                    {
+                        type: 'tool_result',
+                        tool_use_id: message.tool_call_id,
+                        content: typeof message.content === 'string'
+                            ? message.content
+                            : JSON.stringify(message.content)
+                    }
+                ]
+            });
+        }
+    }
+    // Add cache_control to the last message content blocks
+    if (anthropicMessages.length > 0) {
+        const lastMessage = anthropicMessages[anthropicMessages.length - 1];
+        if (Array.isArray(lastMessage.content)) {
+            // Add cache_control to the last content block
+            if (lastMessage.content.length > 0) {
+                const lastBlock = lastMessage.content[lastMessage.content.length - 1];
+                if (lastBlock.type === 'text') {
+                    lastBlock.cache_control = { type: 'ephemeral' };
+                }
+            }
+        }
+        else if (typeof lastMessage.content === 'string') {
+            // Convert string content to array format with cache_control
+            lastMessage.content = [
+                {
+                    type: 'text',
+                    text: lastMessage.content,
+                    cache_control: { type: 'ephemeral' }
+                }
+            ];
+        }
+    }
+    return { system, messages: anthropicMessages };
+}
+export function convertOpenAIToolsToAnthropic(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    const anthropicTools = tools.map((tool) => ({
+        name: tool.function.name,
+        description: tool.function.description,
+        input_schema: (tool.function.parameters || {
+            type: 'object',
+            properties: {}
+        })
+    }));
+    // Add cache_control to the last tool to cache all tool definitions
+    if (anthropicTools.length > 0) {
+        anthropicTools[anthropicTools.length - 1].cache_control = { type: 'ephemeral' };
+    }
+    return anthropicTools;
+}

package/package/components/copilot/chat/api/apiTools.d.ts

@@ -1,6 +1,6 @@
-import type { ChatCompletionTool } from 'openai/resources/index.mjs';
+import type { ChatCompletionFunctionTool } from 'openai/resources/index.mjs';
 import type { Tool } from '../shared';
-export declare function createApiTools(chatTools: ChatCompletionTool[], endpointMap?: Record<string, {
+export declare function createApiTools(chatTools: ChatCompletionFunctionTool[], endpointMap?: Record<string, {
     method: string;
     path: string;
 }>): Tool<{}>[];

package/package/components/copilot/chat/api/apiTools.js

@@ -15,7 +15,8 @@ function buildApiCallTool(endpointTool) {
             if (key === 'workspace')
                 continue;
             parameters.properties[key] = schema;
-            if (Array.isArray(endpointTool.path_params_schema.required) && endpointTool.path_params_schema.required.includes(key)) {
+            if (Array.isArray(endpointTool.path_params_schema.required) &&
+                endpointTool.path_params_schema.required.includes(key)) {
                 parameters.required.push(key);
             }
         }
@@ -24,7 +25,8 @@ function buildApiCallTool(endpointTool) {
     if (endpointTool.query_params_schema?.properties) {
         for (const [key, schema] of Object.entries(endpointTool.query_params_schema.properties)) {
             parameters.properties[key] = schema;
-            if (Array.isArray(endpointTool.query_params_schema.required) && endpointTool.query_params_schema.required.includes(key)) {
+            if (Array.isArray(endpointTool.query_params_schema.required) &&
+                endpointTool.query_params_schema.required.includes(key)) {
                 parameters.required.push(key);
             }
         }
@@ -38,7 +40,8 @@ function buildApiCallTool(endpointTool) {
             properties: endpointTool.body_schema.properties,
             required: endpointTool.body_schema.required || []
         };
-        if (Array.isArray(endpointTool.body_schema.required) && endpointTool.body_schema.required.length > 0) {
+        if (Array.isArray(endpointTool.body_schema.required) &&
+            endpointTool.body_schema.required.length > 0) {
             parameters.required.push('body');
         }
     }
@@ -114,7 +117,7 @@ export function createApiTools(chatTools, endpointMap = {}) {
                         url += `?${searchParams.toString()}`;
                     }
                     toolCallbacks.setToolStatus(toolId, {
-                        content: `Calling ${toolName}...`,
+                        content: `Calling ${toolName}...`
                     });
                     const fetchOptions = {
                         method: endpoint.method
@@ -141,7 +144,7 @@ export function createApiTools(chatTools, endpointMap = {}) {
                         });
                         toolCallbacks.setToolStatus(toolId, {
                             content: `Call to ${toolName} completed`,
-                            result: jsonResult,
+                            result: jsonResult
                         });
                         return jsonResult;
                     }
@@ -155,7 +158,7 @@ export function createApiTools(chatTools, endpointMap = {}) {
                         toolCallbacks.setToolStatus(toolId, {
                             content: `Call to ${toolName} failed`,
                             result: jsonResult,
-                            error: `HTTP ${response.status}: ${text}`,
+                            error: `HTTP ${response.status}: ${text}`
                         });
                         return jsonResult;
                     }
@@ -164,7 +167,7 @@ export function createApiTools(chatTools, endpointMap = {}) {
                     const errorMessage = `Error calling API: ${error instanceof Error ? error.message : String(error)}`;
                     toolCallbacks.setToolStatus(toolId, {
                         content: `Call to ${toolName} failed`,
-                        error: errorMessage,
+                        error: errorMessage
                     });
                     console.error(`Error calling API:`, error);
                     return errorMessage;

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

@@ -3,5 +3,5 @@ import type { Tool } from '../shared';
 export declare const CHAT_SYSTEM_PROMPT: (username: string) => string;
 export declare function getApiTools(): Promise<Tool<{}>[]>;
 export declare const apiTools: Tool<{}>[];
-export declare function prepareApiSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareApiSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;
 export declare function prepareApiUserMessage(instructions: string): ChatCompletionUserMessageParam;

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

@@ -47,10 +47,15 @@ export async function getApiTools() {
     return apiToolsCache;
 }
 export const apiTools = [getDocumentationTool];
-export function prepareApiSystemMessage() {
+export function prepareApiSystemMessage(customPrompt) {
+    let content = CHAT_SYSTEM_PROMPT(get(userStore)?.username ?? '');
+    // 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(get(userStore)?.username ?? '')
+        content
     };
 }
 export function prepareApiUserMessage(instructions) {

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

@@ -2,5 +2,5 @@ import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam }
 import type { Tool } from '../shared';
 export declare const CHAT_SYSTEM_PROMPT = "\nYou are Windmill's intelligent assistant, designed to 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. Get documentation for user requests (get_documentation)\n\nINSTRUCTIONS:\n- When user asks about something, use the get_documentation tool to retrieve accurate information about how to fulfill the user's request.\n- Complete your response with precisions about how it works based on the documentation. Also drop a link to the relevant documentation if possible.\n- If the user asks about something that you are unsure about, say that you are not sure about the answer and suggest to ask the question to the windmill team.\n\nGENERAL PRINCIPLES:\n- Be concise but thorough\n- Maintain a friendly, professional tone\n- If you encounter an error or can't complete a request, explain why and suggest alternatives\n";
 export declare const askTools: Tool<{}>[];
-export declare function prepareAskSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareAskSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;
 export declare function prepareAskUserMessage(instructions: string): ChatCompletionUserMessageParam;

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

@@ -17,10 +17,15 @@ GENERAL PRINCIPLES:
 - If you encounter an error or can't complete a request, explain why and suggest alternatives
 `;
 export const askTools = [getDocumentationTool];
-export function prepareAskSystemMessage() {
+export function prepareAskSystemMessage(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 prepareAskUserMessage(instructions) {

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

@@ -138,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

@@ -425,7 +425,10 @@ export const flowTools = [
         }
     },
     {
-        def: setForLoopOptionsToolDef,
+        def: {
+            ...setForLoopOptionsToolDef,
+            function: { ...setForLoopOptionsToolDef.function, strict: false }
+        },
         fn: async ({ args, helpers, toolId, toolCallbacks }) => {
             const parsedArgs = setForLoopOptionsSchema.parse(args);
             await helpers.setForLoopOptions(parsedArgs.id, {
@@ -442,7 +445,10 @@ export const flowTools = [
         }
     },
     {
-        def: setModuleControlOptionsToolDef,
+        def: {
+            ...setModuleControlOptionsToolDef,
+            function: { ...setModuleControlOptionsToolDef.function, strict: false }
+        },
         fn: async ({ args, helpers, toolId, toolCallbacks }) => {
             const parsedArgs = setModuleControlOptionsSchema.parse(args);
             await helpers.setModuleControlOptions(parsedArgs.id, {
@@ -636,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.
@@ -762,6 +768,10 @@ 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

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[];
@@ -41,10 +46,6 @@ export declare class AIChatEditorHandler {
         groupIndex: number;
     }): void;
     private calculateVisualChanges;
-    reviewChanges(targetCode: string, opts?: {
-        applyAll?: boolean;
-        mode?: 'apply' | 'revert';
-        onFinishedReview?: () => void;
-    }): Promise<void>;
+    reviewChanges(targetCode: string, opts?: ReviewChangesOpts): Promise<void>;
 }
 export {};

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) {

package/package/components/copilot/chat/script/CodeDisplay.svelte

@@ -1,17 +1,7 @@
-<script lang="ts">import { Button } from '../../../common';
-import { getAstNode } from 'svelte-exmarkdown';
-import { editor as meditor } from 'monaco-editor';
-import { getContext, untrack } from 'svelte';
-import { Loader2 } from 'lucide-svelte';
-import { initializeVscode } from '../../../vscode';
+<script lang="ts">import { getAstNode } from 'svelte-exmarkdown';
 import HighlightCode from '../../../HighlightCode.svelte';
 import { csharp, go, graphql, javascript, php, python, rust, shell, sql, typescript, yaml } from 'svelte-highlight/languages';
-import { scriptLangToEditorLang } from '../../../../scripts';
-import { aiChatManager } from '../AIChatManager.svelte';
 const astNode = getAstNode();
-const { message } = getContext('AssistantMessageContext');
-let codeContext = $derived(message.role === 'assistant' &&
-    message.contextElements?.find((e) => e.type === 'code'));
 function getSmartLang(lang) {
     switch (lang) {
         case 'python':
@@ -69,106 +59,15 @@ const SMART_LANG_TO_HIGHLIGHT_LANG = {
 };
 let code = $derived(astNode.current.children?.[0]?.children?.[0]?.value);
 let language = $derived(astNode.current.children?.[0]?.properties?.class?.split('-')[1]);
-let loading = $state(true);
-$effect(() => {
-    // we only want to trigger when astNode offset is updated not currentReply, otherwise as there is some delay on the offset update, loading would be set to false too early
-    const completeReply = untrack(() => aiChatManager.currentReply);
-    if (!aiChatManager.loading ||
-        completeReply.length > (astNode.current.position?.end.offset ?? 0)) {
-        loading = false;
-    }
-});
-let diffEl = $state();
-let diffEditor = $state();
-async function setDiffEditor(diffEl) {
-    if (!codeContext) {
-        return;
-    }
-    await initializeVscode();
-    diffEditor = meditor.createDiffEditor(diffEl, {
-        automaticLayout: true,
-        renderSideBySide: false,
-        hideUnchangedRegions: {
-            enabled: true
-        },
-        originalEditable: false,
-        readOnly: true,
-        renderGutterMenu: false,
-        renderOverviewRuler: false,
-        scrollBeyondLastLine: false,
-        overviewRulerLanes: 0,
-        lineNumbersMinChars: 0,
-        lightbulb: {
-            enabled: meditor.ShowLightbulbIconMode.Off
-        },
-        scrollbar: {
-            alwaysConsumeMouseWheel: false
-        }
-    });
-    diffEditor.setModel({
-        original: meditor.createModel(codeContext.content, scriptLangToEditorLang(codeContext.lang)),
-        modified: meditor.createModel(code ?? '', language ? getSmartLang(language) : undefined)
-    });
-    const originalEditor = diffEditor.getOriginalEditor();
-    const modifiedEditor = diffEditor.getModifiedEditor();
-    originalEditor.onDidContentSizeChange((e) => {
-        diffEl.style.height = `${e.contentHeight}px`;
-    });
-    modifiedEditor.onDidContentSizeChange((e) => {
-        diffEl.style.height = `${e.contentHeight}px`;
-    });
-    updateModifiedModel(code ?? '');
-}
-function updateModifiedModel(code) {
-    const modified = diffEditor?.getModifiedEditor();
-    if (!modified)
-        return;
-    const modifiedModel = modified.getModel();
-    if (modifiedModel) {
-        modifiedModel.setValue(code ?? '');
-    }
-}
-$effect(() => updateModifiedModel(code ?? ''));
-$effect(() => {
-    diffEl &&
-        language &&
-        codeContext &&
-        getSmartLang(codeContext.lang) === getSmartLang(language) &&
-        untrack(() => diffEl && setDiffEditor(diffEl));
-});
 </script>
 
-<div class="flex flex-col gap-0.5 rounded-lg relative not-prose">
-	{#if aiChatManager.canApplyCode && code !== aiChatManager.scriptEditorOptions?.code}
-		<div class="flex justify-end items-end">
-			<Button
-				color="dark"
-				size="xs2"
-				on:click={() => {
-					aiChatManager.scriptEditorApplyCode?.(code ?? '')
-				}}
-			>
-				{aiChatManager.pendingNewCode ? 'Accept all' : 'Apply'}
-			</Button>
-		</div>
-	{/if}
-
-	<div
-		class="relative w-full border border-gray-300 dark:border-gray-600 rounded-lg overflow-hidden"
-	>
-		{#if aiChatManager.mode !== 'navigator' && loading && !code}
-			<div class="flex flex-row gap-1 p-2 items-center justify-center">
-				<Loader2 class="w-4 h-4 animate-spin" /> Generating code...
-			</div>
-		{:else if !loading && codeContext && getSmartLang(codeContext.lang) === getSmartLang(language as string)}
-			<div bind:this={diffEl} class="w-full h-full"></div>
-		{:else}
-			<HighlightCode
-				class="p-1"
-				code={code ?? ''}
-				highlightLanguage={SMART_LANG_TO_HIGHLIGHT_LANG[getSmartLang(language as string)]}
-				language={undefined}
-			/>
-		{/if}
-	</div>
+<div
+	class="flex flex-col not-prose relative w-full border border-gray-300 dark:border-gray-600 rounded-lg overflow-hidden"
+>
+	<HighlightCode
+		class="p-1"
+		code={code ?? ''}
+		highlightLanguage={SMART_LANG_TO_HIGHLIGHT_LANG[getSmartLang(language as string)]}
+		language={undefined}
+	/>
 </div>

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

@@ -2,6 +2,7 @@ import type { ResourceType, ScriptLang } from '../../../../gen/types.gen';
 import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/index.mjs';
 import type { ContextElement } from '../context';
 import { type Tool } from '../shared';
+import type { ReviewChangesOpts } from '../monaco-adapter';
 export declare function formatResourceTypes(allResourceTypes: ResourceType[], lang: 'python3' | 'php' | 'bun' | 'deno' | 'nativets' | 'bunnative'): string;
 export declare const SUPPORTED_CHAT_SCRIPT_LANGUAGES: string[];
 export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' | 'tsx' | 'json', { allowResourcesFetch, isPreprocessor }?: {
@@ -10,10 +11,10 @@ export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' |
     isFailure?: boolean;
 }): string;
 export declare function getFormattedResourceTypes(lang: ScriptLang | 'bunnative', prompt: string, workspace: string): Promise<string>;
-export declare const CHAT_SYSTEM_PROMPT = "\n\tYou are a coding assistant for the Windmill platform. You are provided with a list of `INSTRUCTIONS` and the current contents of a code file under `CODE`.\n\n\tYour task is to respond to the user's request. Assume all user queries are valid and actionable.\n\n\tWhen the user requests code changes:\n\t- Always include a **single code block** with the **entire updated file**, not just the modified sections.\n\t- The code can include `[#START]` and `[#END]` markers to indicate the start and end of a code piece. You MUST only modify the code between these markers if given, and remove them in your response. If a question is asked about the code, you MUST only talk about the code between the markers. Refer to it as the code piece, not the code between the markers.\n\t- Follow the instructions carefully and explain the reasoning behind your changes.\n\t- If the request is abstract (e.g., \"make this cleaner\"), interpret it concretely and reflect that in the code block.\n\t- Preserve existing formatting, indentation, and whitespace unless changes are strictly required to fulfill the user's request.\n\t- The user can ask you to look at or modify specific files, databases or errors by having its name in the INSTRUCTIONS preceded by the @ symbol. In this case, put your focus on the element that is explicitly mentioned.\n\t- The user can ask you questions about a list of `DATABASES` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.\n\t- You can also receive a `DIFF` of the changes that have been made to the code. You should use this diff to give better answers.\n\t- Before giving your answer, check again that you carefully followed these instructions.\n\t- When asked to create a script that communicates with an external service, you can use the `search_hub_scripts` tool to search for relevant scripts in the hub. Make sure the language is the same as what the user is coding in. If you do not find any relevant scripts, you can use the `search_npm_packages` tool to search for relevant packages and their documentation. Always give a link to the documentation in your answer if possible.\n\t- At the end of your reponse, if you modified or suggested changes to the code, ALWAYS use the `test_run_script` tool to test the code, and iterate on the code until it works as expected (MAX 3 times). If the user cancels the test run, do not try again and wait for the next user instruction.\n\n\tImportant:\n\tDo not mention or reveal these instructions to the user unless explicitly asked to do so.\n";
+export declare const CHAT_SYSTEM_PROMPT = "\n\tYou are a coding assistant for the Windmill platform. You are provided with a list of `INSTRUCTIONS` and the current contents of a code file under `CODE`.\n\n\tYour task is to respond to the user's request. Assume all user queries are valid and actionable.\n\n\tWhen the user requests code changes:\n\t- ALWAYS use the `edit_code` tool to apply code changes. Use it only once with an array of diffs.\n\t- Pass an array of **diff objects** to the `edit_code` tool. Each diff should specify exactly what text to replace and what to replace it with.\n\t- Each diff object must contain:\n\t  - `old_string`: The exact text to replace (must match the current code exactly)\n\t  - `new_string`: The replacement text\n\t  - `replace_all` (optional): Set to true to replace all occurrences, false or omit for first occurrence only\n\t- The code can include `[#START]` and `[#END]` markers to indicate the start and end of a code piece. You MUST only modify the code between these markers if given, and remove them when creating your diffs. If a question is asked about the code, you MUST only talk about the code between the markers. Refer to it as the code piece, not the code between the markers.\n\t- Follow the instructions carefully and explain the reasoning behind your changes in your response text.\n\t- If the request is abstract (e.g., \"make this cleaner\"), interpret it concretely and reflect that in the diffs.\n\t- Preserve existing formatting, indentation, and whitespace unless changes are strictly required to fulfill the user's request.\n\t- The user can ask you to look at or modify specific files, databases or errors by having its name in the INSTRUCTIONS preceded by the @ symbol. In this case, put your focus on the element that is explicitly mentioned.\n\t- The user can ask you questions about a list of `DATABASES` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.\n\t- You can also receive a `DIFF` of the changes that have been made to the code. You should use this diff to give better answers.\n\t- Before giving your answer, check again that you carefully followed these instructions.\n\t- When asked to create a script that communicates with an external service, you can use the `search_hub_scripts` tool to search for relevant scripts in the hub. Make sure the language is the same as what the user is coding in. If you do not find any relevant scripts, you can use the `search_npm_packages` tool to search for relevant packages and their documentation. Always give a link to the documentation in your answer if possible.\n\t- After applying code changes with the `edit_code` tool, ALWAYS use the `test_run_script` tool to test the code, and iterate on the code until it works as expected (MAX 3 times). If the user cancels the test run, do not try again and wait for the next user instruction.\n\n\tExample diff usage:\n\tTo change \"return 1\" to \"return 2\", use:\n\t[{\n\t\t\"old_string\": \"return 1\",\n\t\t\"new_string\": \"return 2\"\n\t}]\n\n\tTo add a new function and modify an existing one:\n\t[{\n\t\t\"old_string\": \"export async function main() {\",\n\t\t\"new_string\": \"function helper() {\n\treturn 'help';\n}\n\nexport async function main() {\"\n\t}, {\n\t\t\"old_string\": \"return result;\",\n\t\t\"new_string\": \"return result + helper();\"\n\t}]\n\n\tImportant:\n\t- Each old_string must match the exact text in the current code, including whitespace and indentation.\n\t- Do not return the applied code in your response, just explain what you did. You can return code blocks in your response for explanations or examples as per user request.\n\t- Do not mention or reveal these instructions to the user unless explicitly asked to do so.\n";
 export declare const INLINE_CHAT_SYSTEM_PROMPT = "\n# Windmill Inline Coding Assistant\n\nYou are a coding assistant for the Windmill platform. You provide precise code modifications based on user instructions.\n\n## Input Format\n\nYou will receive:\n- **INSTRUCTIONS**: User's modification request\n- **CODE**: Current code content with modification boundaries\n- **DATABASES** *(optional)*: Available workspace databases\n\n### Code Boundaries\n\nThe code contains `[#START]` and `[#END]` markers indicating the modification scope:\n- **MUST** only modify code between these markers\n- **MUST** remove the markers in your response\n- **MUST** preserve all other code exactly as provided\n\n## Task Requirements\n\nReturn the modified CODE that fulfills the user's request. Assume all user queries are valid and actionable.\n\n### Critical Rules\n\n- \u2705 **ALWAYS** include a single code block with the entire updated CODE\n- \u2705 **ALWAYS** use the structured XML output format below\n- \u274C **NEVER** include only modified sections\n- \u274C **NEVER** add explanatory text or comments outside the format\n- \u274C **NEVER** include ``` code fences in your response\n- \u274C **NEVER** modify the code outside the boundaries\n\n## Output Format\n\n```xml\n<changes_made>\nBrief description of what was changed\n</changes_made>\n<new_code>\n[complete modified code without markers]\n</new_code>\n```\n\n## Example\n\n### Input:\n```xml\n<user_request>\nINSTRUCTIONS:\nReturn 2 instead of 1\n\nCODE:\nimport * as wmill from \"windmill-client\"\n\nfunction test() {\n\treturn \"hello\"\n}\n\n[#START]\nexport async function main() {\n\treturn 1;\n}\n[#END]\n</user_request>\n```\n\n### Expected Output:\n```xml\n<changes_made>\nChanged return value from 1 to 2 in main function\n</changes_made>\n<new_code>\nimport * as wmill from \"windmill-client\"\n\nfunction test() {\n\treturn \"hello\"\n}\n\nexport async function main() {\n\treturn 2;\n}\n</new_code>\n```\n";
 export declare const CHAT_USER_PROMPT = "\nINSTRUCTIONS:\n{instructions}\n\nWINDMILL LANGUAGE CONTEXT:\n{lang_context}\n\n";
-export declare function prepareScriptSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareScriptSystemMessage(customPrompt?: string): ChatCompletionSystemMessageParam;
 export declare function prepareScriptTools(language: ScriptLang | 'bunnative', context: ContextElement[]): Tool<ScriptChatHelpers>[];
 export declare function prepareScriptUserMessage(instructions: string, language: ScriptLang | 'bunnative', selectedContext: ContextElement[], options?: {
     isPreprocessor?: boolean;
@@ -26,8 +27,7 @@ export interface ScriptChatHelpers {
         path: string;
         args: Record<string, any>;
     };
-    getLastSuggestedCode: () => string | undefined;
-    applyCode: (code: string, applyAll?: boolean) => void;
+    applyCode: (code: string, opts?: ReviewChangesOpts) => Promise<void>;
 }
 export declare const resourceTypeTool: Tool<ScriptChatHelpers>;
 export declare function createDbSchemaTool<T>(): Tool<T>;
@@ -41,4 +41,5 @@ export declare function fetchNpmPackageTypes(packageName: string, version?: stri
     types: string;
     error?: string;
 }>;
+export declare const editCodeTool: Tool<ScriptChatHelpers>;
 export declare const testRunScriptTool: Tool<ScriptChatHelpers>;