windmill-components 1.558.3 → 1.596.0

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

@@ -1,12 +1,22 @@
 import { dfs } from '../../../flows/previousResults';
+// Helper to find module by ID in a flow
+export function getModuleById(flow, moduleId) {
+    const allModules = dfs(moduleId, flow, false);
+    return allModules[0];
+}
 export function getIndexInNestedModules(flow, id) {
     const accessingModules = dfs(id, flow, true).reverse();
+    if (accessingModules.length === 0) {
+        // Module not found in flow
+        return null;
+    }
     let parent = flow.value.modules;
     let lastIndex = -1;
     for (const [ai, am] of accessingModules.entries()) {
         const index = parent.findIndex((m) => m.id === am.id);
         if (index === -1) {
-            throw new Error(`Module not found: ${am.id} in ${parent.map((m) => m.id).join(', ')}`);
+            // Module no longer exists in expected location (may have been deleted with parent)
+            return null;
         }
         lastIndex = index;
         if (ai === accessingModules.length - 1) {
@@ -20,56 +30,79 @@ export function getIndexInNestedModules(flow, id) {
             parent[index].value.type === 'branchone') {
             const branchIdx = parent[index].value.branches.findIndex((b) => b.modules.some((m) => m.id === accessingModules[ai + 1].id));
             if (branchIdx === -1) {
-                throw new Error(`Branch not found: ${am.id} in ${parent[index].value.branches.map((b) => b.modules.map((m) => m.id).join(', ')).join(';')}`);
+                // Module no longer exists in branch (may have been deleted)
+                return null;
             }
             parent = parent[index].value.branches[branchIdx].modules;
         }
         else {
-            throw new Error('Module is not a for loop or branch');
+            // Unexpected module type in path
+            return null;
         }
     }
     if (lastIndex === -1) {
-        throw new Error('Module not found, should have been caught earlier');
+        return null;
     }
     return {
         index: lastIndex,
         modules: parent
     };
 }
-export function getNestedModules(flow, id, branchIndex) {
-    const { index, modules } = getIndexInNestedModules(flow, id);
-    // we know index is correct because we've already checked it in getIndexInNestedModules
-    const module = modules[index];
+/**
+ * Collects all module IDs from an array of modules and their nested structures
+ */
+export function collectAllModuleIdsFromArray(modules) {
+    const ids = [];
+    for (const module of modules) {
+        ids.push(...collectAllModuleIds(module));
+    }
+    return ids;
+}
+/**
+ * Recursively collects all module IDs from a module and its nested structures
+ */
+export function collectAllModuleIds(module) {
+    const ids = [module.id];
     if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-        return module.value.modules;
+        if (module.value.modules) {
+            for (const nested of module.value.modules) {
+                ids.push(...collectAllModuleIds(nested));
+            }
+        }
     }
-    else if (branchIndex !== undefined &&
-        (module.value.type === 'branchall' || module.value.type === 'branchone')) {
-        if (module.value.type === 'branchone' && branchIndex === -1) {
-            return module.value.default;
+    else if (module.value.type === 'branchone') {
+        if (module.value.branches) {
+            for (const branch of module.value.branches) {
+                if (branch.modules) {
+                    for (const nested of branch.modules) {
+                        ids.push(...collectAllModuleIds(nested));
+                    }
+                }
+            }
+        }
+        if (module.value.default) {
+            for (const nested of module.value.default) {
+                ids.push(...collectAllModuleIds(nested));
+            }
         }
-        const branch = module.value.branches[branchIndex];
-        if (!branch) {
-            throw new Error(`Branch not found: ${id} in ${module.value.branches.map((b) => b.modules.map((m) => m.id).join(', ')).join(';')}`);
+    }
+    else if (module.value.type === 'branchall') {
+        if (module.value.branches) {
+            for (const branch of module.value.branches) {
+                if (branch.modules) {
+                    for (const nested of branch.modules) {
+                        ids.push(...collectAllModuleIds(nested));
+                    }
+                }
+            }
         }
-        return branch.modules;
     }
     else if (module.value.type === 'aiagent') {
-        return module.value.tools;
-    }
-    else {
-        throw new Error('Module is not a loop or branch');
-    }
-}
-export function aiModuleActionToBgColor(action) {
-    switch (action) {
-        case 'modified':
-            return '!bg-orange-200 dark:!bg-orange-800';
-        case 'added':
-            return '!bg-green-200 dark:!bg-green-800';
-        case 'removed':
-            return '!bg-red-200/50 dark:!bg-red-800/50';
-        default:
-            return '';
+        if (module.value.tools) {
+            for (const tool of module.value.tools) {
+                ids.push(tool.id);
+            }
+        }
     }
+    return ids;
 }

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

@@ -214,13 +214,13 @@ async function getDocumentation(args) {
             'Content-Type': 'application/json'
         },
         body: JSON.stringify({
-            model: 'inkeep-rag',
-            messages: [{ role: 'user', content: args.request }],
-            response_format: {
-                type: 'json_object'
-            }
+            query: args.request
         })
     });
+    if (!retrieval.ok) {
+        const errorText = await retrieval.text();
+        throw new Error(errorText);
+    }
     const data = await retrieval.json();
     if (!data.choices?.[0]?.message?.content) {
         return 'No documentation found for this request';
@@ -263,11 +263,11 @@ const getTriggerableComponentsTool = {
     def: GET_TRIGGERABLE_COMPONENTS_TOOL,
     fn: async ({ toolId, toolCallbacks }) => {
         toolCallbacks.setToolStatus(toolId, {
-            content: 'Scanning the page...',
+            content: 'Scanning the page...'
         });
         const components = getTriggerableComponents();
         toolCallbacks.setToolStatus(toolId, {
-            content: 'Scanned the page',
+            content: 'Scanned the page'
         });
         return components;
     }
@@ -290,9 +290,13 @@ export const getDocumentationTool = {
             return docResult;
         }
         catch (error) {
-            toolCallbacks.setToolStatus(toolId, { content: 'Error getting documentation', error: 'Error getting documentation' });
+            toolCallbacks.setToolStatus(toolId, {
+                content: 'Error getting documentation',
+                error: 'Error getting documentation'
+            });
             console.error('Error getting documentation:', error);
-            return 'Failed to get documentation, pursuing with the user request...';
+            const errorMessage = error instanceof Error ? error.message : 'An error occurred while getting documentation';
+            return `Failed to get documentation: ${errorMessage}, pursuing with the user request...`;
         }
     }
 };
@@ -306,7 +310,10 @@ const getAvailableResourcesTool = {
             return resources;
         }
         catch (error) {
-            toolCallbacks.setToolStatus(toolId, { content: 'Error getting available resources', error: 'Error getting available resources' });
+            toolCallbacks.setToolStatus(toolId, {
+                content: 'Error getting available resources',
+                error: 'Error getting available resources'
+            });
             console.error('Error getting available resources:', error);
             return 'Failed to get available resources, pursuing with the user request...';
         }

package/package/components/copilot/chat/openai-responses.d.ts

@@ -0,0 +1,16 @@
+import OpenAI from 'openai';
+import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
+import { type Tool, type ToolCallbacks } from './shared';
+import type { ResponseStream } from 'openai/lib/responses/ResponseStream.mjs';
+import type { AIProviderModel } from '../../../gen';
+export declare function getOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[]): Promise<ResponseStream<null>>;
+export declare function getOpenAIResponsesCompletionStream(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[]): AsyncGenerator<OpenAI.Chat.Completions.ChatCompletionChunk>;
+export declare function parseOpenAIResponsesCompletion(runner: ResponseStream, callbacks: ToolCallbacks & {
+    onNewToken: (token: string) => void;
+    onMessageEnd: () => void;
+}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any): Promise<boolean>;
+export declare function getNonStreamingOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, testOptions?: {
+    apiKey?: string;
+    resourcePath?: string;
+    forceModelProvider: AIProviderModel;
+}): Promise<string>;

package/package/components/copilot/chat/openai-responses.js

@@ -0,0 +1,318 @@
+import OpenAI, { OpenAIError } from 'openai';
+import { getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
+import { processToolCall } from './shared';
+import { OpenAPI } from '../../../gen';
+// Conversion utilities for Responses API
+function convertMessagesToResponsesInput(messages) {
+    const systemMessage = messages.find((m) => m.role === 'system');
+    const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+    const input = [];
+    for (const m of nonSystemMessages) {
+        // Handle assistant messages with tool calls
+        if (m.role === 'assistant' && 'tool_calls' in m && m.tool_calls) {
+            // First, add the assistant's text content if it exists
+            if ('content' in m && m.content) {
+                input.push({
+                    type: 'message',
+                    role: 'assistant',
+                    content: m.content
+                });
+            }
+            // Then add tool calls
+            for (const toolCall of m.tool_calls) {
+                if (toolCall.type === 'function') {
+                    // Validate that required fields exist
+                    if (!toolCall.function.name || toolCall.function.name.trim() === '') {
+                        console.warn('Skipping tool call with empty name:', toolCall);
+                        continue;
+                    }
+                    input.push({
+                        type: 'function_call',
+                        call_id: toolCall.id,
+                        name: toolCall.function.name,
+                        arguments: toolCall.function.arguments
+                    });
+                }
+            }
+        }
+        // Handle tool result messages
+        else if (m.role === 'tool' && 'content' in m && 'tool_call_id' in m) {
+            input.push({
+                type: 'function_call_output',
+                call_id: m.tool_call_id,
+                output: typeof m.content === 'string' ? m.content : JSON.stringify(m.content)
+            });
+        }
+        // Handle regular messages
+        else if ('content' in m && m.content !== null && m.content !== undefined) {
+            input.push({
+                type: 'message',
+                role: m.role === 'developer' ? 'developer' : m.role === 'assistant' ? 'assistant' : 'user',
+                content: m.content
+            });
+        }
+    }
+    return {
+        instructions: systemMessage && 'content' in systemMessage
+            ? typeof systemMessage.content === 'string'
+                ? systemMessage.content
+                : JSON.stringify(systemMessage.content)
+            : undefined,
+        input
+    };
+}
+function convertCompletionConfigToResponsesConfig(config) {
+    const responsesConfig = {
+        model: config.model
+    };
+    // Map max_tokens or max_completion_tokens to max_output_tokens
+    if ('max_completion_tokens' in config && config.max_completion_tokens) {
+        responsesConfig.max_output_tokens = config.max_completion_tokens;
+    }
+    else if ('max_tokens' in config && config.max_tokens) {
+        responsesConfig.max_output_tokens = config.max_tokens;
+    }
+    // Keep other relevant fields
+    if (config.temperature !== undefined) {
+        responsesConfig.temperature = config.temperature;
+    }
+    if ('tools' in config && config.tools && config.tools.length > 0) {
+        responsesConfig.tools = config.tools.map((tool) => {
+            if (tool.type === 'function' && 'function' in tool) {
+                // Convert from Completions format to Responses format
+                return {
+                    type: 'function',
+                    name: tool.function.name,
+                    description: tool.function.description,
+                    parameters: tool.function.parameters,
+                    strict: tool.function.strict ?? null
+                };
+            }
+            // Pass through other tool types unchanged
+            return tool;
+        });
+    }
+    return responsesConfig;
+}
+export async function getOpenAIResponsesCompletion(messages, abortController, tools) {
+    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true, tools });
+    const { instructions, input } = convertMessagesToResponsesInput(messages);
+    const responsesConfig = convertCompletionConfigToResponsesConfig(config);
+    const openaiClient = workspaceAIClients.getOpenaiClient();
+    const runner = openaiClient.responses.stream({
+        ...responsesConfig,
+        input,
+        ...(instructions ? { instructions } : {})
+    }, {
+        signal: abortController.signal,
+        headers: {
+            'X-Provider': provider
+        }
+    });
+    return runner;
+}
+// Wrapper that converts ResponseStream to ChatCompletionChunk format for lib.ts usage
+export async function* getOpenAIResponsesCompletionStream(messages, abortController, tools) {
+    const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true, tools });
+    const { instructions, input } = convertMessagesToResponsesInput(messages);
+    const responsesConfig = convertCompletionConfigToResponsesConfig(config);
+    const openaiClient = workspaceAIClients.getOpenaiClient();
+    const runner = openaiClient.responses.stream({
+        ...responsesConfig,
+        input,
+        ...(instructions ? { instructions } : {})
+    }, {
+        signal: abortController.signal,
+        headers: {
+            'X-Provider': provider
+        }
+    });
+    // Convert ResponseStream events to ChatCompletionChunk format
+    for await (const event of runner) {
+        if (event.type === 'response.output_text.delta') {
+            // Yield text chunks in ChatCompletionChunk format
+            yield {
+                id: 'chatcmpl-' + Date.now(),
+                object: 'chat.completion.chunk',
+                created: Date.now(),
+                model: responsesConfig.model,
+                choices: [
+                    {
+                        index: 0,
+                        delta: {
+                            content: event.delta || ''
+                        },
+                        finish_reason: null
+                    }
+                ]
+            };
+        }
+    }
+}
+export async function parseOpenAIResponsesCompletion(runner, callbacks, messages, addedMessages, tools, helpers) {
+    let toolCallsToProcess = [];
+    let error = null;
+    let textContent = '';
+    let toolCallsMap = {};
+    // Streaming state tracking
+    let currentStreamingTool = undefined;
+    let accumulatedJson = '';
+    // Handle text streaming
+    runner.on('response.output_text.delta', (event) => {
+        callbacks.onNewToken(event.delta);
+        textContent += event.delta;
+    });
+    // Handle new output items (including function calls)
+    runner.on('response.output_item.added', (event) => {
+        const item = event.item;
+        if (item.type === 'function_call' && item.id) {
+            const tool = tools.find((t) => t.def.function.name === item.name);
+            const shouldStream = tool?.streamArguments ?? false;
+            toolCallsMap[item.id] = {
+                name: item.name,
+                call_id: item.call_id
+            };
+            // Reset streaming state for new tool
+            accumulatedJson = '';
+            currentStreamingTool = { itemId: item.id, shouldStream, toolName: item.name };
+            // Show temporary loading state for the tool call
+            callbacks.onMessageEnd();
+            callbacks.setToolStatus(`${item.id}`, {
+                isLoading: true,
+                content: `Calling ${item.name}...`,
+                toolName: item.name,
+                isStreamingArguments: shouldStream,
+                showFade: tool?.showFade,
+                showDetails: tool?.showDetails
+            });
+        }
+    });
+    // Stream function call arguments incrementally
+    runner.on('response.function_call_arguments.delta', (event) => {
+        if (currentStreamingTool?.shouldStream && currentStreamingTool.itemId === event.item_id) {
+            accumulatedJson += event.delta;
+            try {
+                const parsed = JSON.parse(accumulatedJson);
+                callbacks.setToolStatus(`${event.item_id}`, {
+                    parameters: parsed,
+                    isStreamingArguments: true,
+                    isLoading: true
+                });
+            }
+            catch {
+                // JSON incomplete, display as raw string
+                callbacks.setToolStatus(`${event.item_id}`, {
+                    parameters: accumulatedJson,
+                    isStreamingArguments: true,
+                    isLoading: true
+                });
+            }
+        }
+    });
+    // Handle function call arguments done
+    runner.on('response.function_call_arguments.done', (event) => {
+        // Clear streaming state
+        currentStreamingTool = undefined;
+        callbacks.setToolStatus(`${event.item_id}`, {
+            isStreamingArguments: false
+        });
+        // Retrieve tool call metadata from map
+        const metadata = toolCallsMap[event.item_id];
+        if (!metadata) {
+            console.error('Missing tool call metadata for:', event.item_id);
+            return;
+        }
+        // Convert to OpenAI format for compatibility with existing tool processing
+        toolCallsToProcess.push({
+            id: event.item_id,
+            type: 'function',
+            function: {
+                name: metadata.name,
+                arguments: event.arguments
+            }
+        });
+    });
+    // Handle errors
+    runner.on('error', (err) => {
+        currentStreamingTool = undefined;
+        console.error('OpenAI Responses stream error:', err);
+        error = err;
+    });
+    // Wait for completion
+    await runner.done();
+    // Add text message if we got any text
+    if (textContent) {
+        const assistantMessage = { role: 'assistant', content: textContent };
+        messages.push(assistantMessage);
+        addedMessages.push(assistantMessage);
+        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 async function getNonStreamingOpenAIResponsesCompletion(messages, abortController, testOptions) {
+    const { provider, config } = getProviderAndCompletionConfig({
+        messages,
+        stream: false,
+        forceModelProvider: testOptions?.forceModelProvider
+    });
+    const { instructions, input } = convertMessagesToResponsesInput(messages);
+    const responsesConfig = convertCompletionConfigToResponsesConfig(config);
+    const fetchOptions = {
+        signal: abortController.signal,
+        headers: {
+            'X-Provider': provider
+        }
+    };
+    if (testOptions?.resourcePath) {
+        fetchOptions.headers = {
+            ...fetchOptions.headers,
+            'X-Resource-Path': testOptions.resourcePath
+        };
+    }
+    else if (testOptions?.apiKey) {
+        fetchOptions.headers = {
+            ...fetchOptions.headers,
+            'X-API-Key': testOptions.apiKey
+        };
+    }
+    const openaiClient = testOptions?.apiKey
+        ? new OpenAI({
+            baseURL: `${location.origin}${OpenAPI.BASE}/ai/proxy`,
+            apiKey: 'fake-key',
+            defaultHeaders: {
+                Authorization: '' // a non empty string will be unable to access Windmill backend proxy
+            },
+            dangerouslyAllowBrowser: true
+        })
+        : workspaceAIClients.getOpenaiClient();
+    const response = await openaiClient.responses.create({
+        ...responsesConfig,
+        input,
+        ...(instructions ? { instructions } : {})
+    }, fetchOptions);
+    return response.output_text || '';
+}

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

@@ -13,12 +13,14 @@ export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' |
 }): string;
 export declare function getFormattedResourceTypes(lang: ScriptLang | 'bunnative', prompt: string, workspace: string): Promise<string>;
 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(currentModel: AIProviderModel, customPrompt?: string): ChatCompletionSystemMessageParam;
-export declare function prepareScriptTools(currentModel: AIProviderModel, language: ScriptLang | 'bunnative', context: ContextElement[]): Tool<ScriptChatHelpers>[];
-export declare function prepareScriptUserMessage(instructions: string, language: ScriptLang | 'bunnative', selectedContext: ContextElement[], options?: {
+export declare function prepareInlineChatSystemPrompt(lang: ScriptLang | 'bunnative'): string;
+export declare const CHAT_USER_PROMPT = "\nINSTRUCTIONS:\n{instructions}\n\n";
+export declare function prepareScriptSystemMessage(currentModel: AIProviderModel, language: ScriptLang | 'bunnative', options?: {
     isPreprocessor?: boolean;
-}): ChatCompletionUserMessageParam;
+    allowResourcesFetch?: boolean;
+}, customPrompt?: string): ChatCompletionSystemMessageParam;
+export declare function prepareScriptTools(currentModel: AIProviderModel, language: ScriptLang | 'bunnative', context: ContextElement[]): Tool<ScriptChatHelpers>[];
+export declare function prepareScriptUserMessage(instructions: string, selectedContext: ContextElement[]): ChatCompletionUserMessageParam;
 export declare const MAX_SCHEMA_LENGTH: number;
 export interface ScriptChatHelpers {
     getScriptOptions: () => {