windmill-components 1.522.0 → 1.531.0

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

@@ -0,0 +1,192 @@
+import { get } from 'svelte/store';
+import { workspaceStore } from '../../../../stores';
+import { McpService } from '../../../../gen/services.gen';
+function buildApiCallTool(endpointTool) {
+    // Build the parameters schema for OpenAI function calling
+    const parameters = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+    // Add path parameters
+    if (endpointTool.path_params_schema?.properties) {
+        for (const [key, schema] of Object.entries(endpointTool.path_params_schema.properties)) {
+            // Skip workspace parameter as it's auto-filled
+            if (key === 'workspace')
+                continue;
+            parameters.properties[key] = schema;
+            if (Array.isArray(endpointTool.path_params_schema.required) && endpointTool.path_params_schema.required.includes(key)) {
+                parameters.required.push(key);
+            }
+        }
+    }
+    // Add query parameters
+    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)) {
+                parameters.required.push(key);
+            }
+        }
+    }
+    // Add body parameters
+    if (endpointTool.body_schema?.properties) {
+        // For body params, we wrap them in a 'body' object
+        parameters.properties.body = {
+            type: 'object',
+            description: 'Request body',
+            properties: endpointTool.body_schema.properties,
+            required: endpointTool.body_schema.required || []
+        };
+        if (Array.isArray(endpointTool.body_schema.required) && endpointTool.body_schema.required.length > 0) {
+            parameters.required.push('body');
+        }
+    }
+    return {
+        type: 'function',
+        function: {
+            name: endpointTool.name,
+            description: endpointTool.instructions || endpointTool.description,
+            parameters
+        }
+    };
+}
+function buildToolsFromEndpoints(endpointTools) {
+    const tools = [];
+    const endpointMap = {};
+    for (const endpointTool of endpointTools) {
+        const tool = buildApiCallTool(endpointTool);
+        tools.push(tool);
+        // Store the endpoint info in the map
+        endpointMap[endpointTool.name] = {
+            method: endpointTool.method,
+            path: endpointTool.path
+        };
+    }
+    return { tools, endpointMap };
+}
+export function createApiTools(chatTools, endpointMap = {}) {
+    return chatTools.map((chatTool) => {
+        const toolName = chatTool.function.name;
+        const endpoint = endpointMap[toolName];
+        const method = endpoint?.method?.toUpperCase() || 'GET';
+        // Determine if tool needs confirmation based on method
+        const needsConfirmation = ['DELETE', 'POST', 'PUT', 'PATCH'].includes(method);
+        return {
+            def: chatTool,
+            requiresConfirmation: needsConfirmation,
+            confirmationMessage: `Run ${toolName}`,
+            showDetails: true,
+            fn: async ({ args, toolId, toolCallbacks }) => {
+                const toolName = chatTool.function.name;
+                const endpoint = endpointMap[toolName];
+                if (!endpoint) {
+                    throw new Error(`No endpoint mapping found for tool ${toolName}`);
+                }
+                try {
+                    const workspace = get(workspaceStore);
+                    let path = endpoint.path.replace('{workspace}', workspace);
+                    // Build URL with path parameters
+                    let url = `/api${path}`;
+                    const queryParams = {};
+                    let requestBody = undefined;
+                    // Process arguments
+                    for (const [key, value] of Object.entries(args)) {
+                        if (key === 'body') {
+                            requestBody = value;
+                            continue;
+                        }
+                        // Check if this is a path parameter
+                        if (url.includes(`{${key}}`)) {
+                            url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
+                        }
+                        else {
+                            // Assume it's a query parameter
+                            queryParams[key] = String(value);
+                        }
+                    }
+                    // Add query parameters to URL if needed
+                    if (Object.keys(queryParams).length > 0) {
+                        const searchParams = new URLSearchParams();
+                        for (const [key, value] of Object.entries(queryParams)) {
+                            searchParams.append(key, value);
+                        }
+                        url += `?${searchParams.toString()}`;
+                    }
+                    toolCallbacks.setToolStatus(toolId, {
+                        content: `Calling ${toolName}...`,
+                    });
+                    const fetchOptions = {
+                        method: endpoint.method
+                    };
+                    // Add request body for POST/PUT/PATCH methods
+                    if (requestBody && ['POST', 'PUT', 'PATCH'].includes(endpoint.method.toUpperCase())) {
+                        fetchOptions.headers = {
+                            'Content-Type': 'application/json'
+                        };
+                        fetchOptions.body = JSON.stringify(requestBody);
+                    }
+                    const response = await fetch(url, fetchOptions);
+                    if (response.ok) {
+                        let result = '';
+                        if (response.headers.get('content-type')?.includes('application/json')) {
+                            result = await response.json();
+                        }
+                        else {
+                            result = await response.text();
+                        }
+                        const jsonResult = JSON.stringify({
+                            success: true,
+                            data: result
+                        });
+                        toolCallbacks.setToolStatus(toolId, {
+                            content: `Call to ${toolName} completed`,
+                            result: jsonResult,
+                        });
+                        return jsonResult;
+                    }
+                    else {
+                        const text = await response.text();
+                        const jsonResult = JSON.stringify({
+                            success: false,
+                            error: text,
+                            status: response.status
+                        });
+                        toolCallbacks.setToolStatus(toolId, {
+                            content: `Call to ${toolName} failed`,
+                            result: jsonResult,
+                            error: `HTTP ${response.status}: ${text}`,
+                        });
+                        return jsonResult;
+                    }
+                }
+                catch (error) {
+                    const errorMessage = `Error calling API: ${error instanceof Error ? error.message : String(error)}`;
+                    toolCallbacks.setToolStatus(toolId, {
+                        content: `Call to ${toolName} failed`,
+                        error: errorMessage,
+                    });
+                    console.error(`Error calling API:`, error);
+                    return errorMessage;
+                }
+            }
+        };
+    });
+}
+export async function loadApiTools() {
+    try {
+        // Fetch the list of available MCP tools from the backend
+        const endpointTools = await McpService.listMcpTools({
+            workspace: get(workspaceStore)
+        });
+        // Build tools from the endpoint definitions
+        const { tools: apiTools, endpointMap } = buildToolsFromEndpoints(endpointTools);
+        // Create executable tools
+        const executableApiTools = createApiTools(apiTools, endpointMap);
+        return executableApiTools;
+    }
+    catch (error) {
+        console.error('Failed to load API tools:', error);
+        return [];
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/index.mjs';
+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 prepareApiUserMessage(instructions: string): ChatCompletionUserMessageParam;

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

@@ -0,0 +1,61 @@
+import { loadApiTools } from './apiTools';
+import { getDocumentationTool } from '../navigator/core';
+import { userStore } from '../../../../stores';
+import { get } from 'svelte/store';
+export const CHAT_SYSTEM_PROMPT = (username) => `
+You are Windmill's intelligent assistant, designed to interact with the platform via API endpoints and answer questions about its functionality. Your purpose is to help the user directly query and manipulate Windmill resources through API calls.
+
+Windmill 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.
+
+You have access to these tools:
+1. Get documentation for user requests (get_documentation)
+2. A comprehensive list of API endpoints to interact with the Windmill backend
+
+INSTRUCTIONS:
+- You can directly query, list, create, update, and delete various Windmill resources like scripts, flows, jobs, resources, variables, schedules, and workers through the provided API tools.
+- When users ask about specific data or want to perform operations, use the appropriate API endpoints to fulfill their requests.
+- Use get_documentation to retrieve accurate information about features, concepts, and best practices when needed.
+- Always present API results in a clear, readable format for the user.
+- If you need to make multiple related API calls to fulfill a request, do so systematically and explain what you're doing.
+- When showing lists of items, provide meaningful summaries rather than overwhelming the user with raw data.
+- If an API call fails, explain the error clearly and suggest alternatives if applicable.
+- If the user cancels the request, do not try again and ask for the user if he wants to make a new request with different instructions.
+- For endpoints other that GET requiring to send a path, ask the user if he wants the path to be on a folder, or to be on its user's folder. Folder path looks like f/{folder_name}/{resource_path}, and user's folder path looks like u/${username}/{resource_path}.
+- If an endpoint requires a resource_type, first fetch the available resourceTypes.
+
+API CAPABILITIES:
+- Query jobs, scripts, flows, and their execution history
+- List and manage resources and variables
+- View schedules and worker information
+- Search through job logs (if enterprise features are enabled)
+- Access detailed information about any Windmill resource
+
+GENERAL PRINCIPLES:
+- Be direct and action-oriented - use the API tools to fulfill user requests
+- Provide clear summaries of API responses
+- Maintain a helpful, professional tone
+- If you encounter an error or can't complete a request, explain why and suggest alternatives
+- Complete your responses with relevant documentation links when applicable
+
+Always use the provided API tools to directly interact with the Windmill platform and provide users with the information they need.
+`;
+let apiToolsCache = null;
+export async function getApiTools() {
+    if (apiToolsCache === null) {
+        apiToolsCache = await loadApiTools();
+    }
+    return apiToolsCache;
+}
+export const apiTools = [getDocumentationTool];
+export function prepareApiSystemMessage() {
+    return {
+        role: 'system',
+        content: CHAT_SYSTEM_PROMPT(get(userStore)?.username ?? '')
+    };
+}
+export function prepareApiUserMessage(instructions) {
+    return {
+        role: 'user',
+        content: instructions
+    };
+}

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

@@ -175,11 +175,11 @@ const flowHelpers = {
             const { input_transforms, schema } = await loadSchemaFromModule(module);
             module.value.input_transforms = input_transforms;
             refreshStateStore(flowStore);
-            if ($flowStateStore[id]) {
-                $flowStateStore[id].schema = schema;
+            if (flowStateStore.val[id]) {
+                flowStateStore.val[id].schema = schema;
             }
             else {
-                $flowStateStore[id] = {
+                flowStateStore.val[id] = {
                     schema
                 };
             }
@@ -266,7 +266,6 @@ const flowHelpers = {
             }
         }
         if (location.type === 'preprocessor' || location.type === 'failure') {
-            $flowStateStore = $flowStateStore;
             refreshStateStore(flowStore);
             setModuleStatus(location.type, 'added');
             return location.type;
@@ -279,7 +278,6 @@ const flowHelpers = {
             if (['branchone', 'branchall'].includes(step.type)) {
                 await flowModuleSchemaMap?.addBranch(newModule.id);
             }
-            $flowStateStore = $flowStateStore;
             refreshStateStore(flowStore);
             setModuleStatus(newModule.id, 'added');
             return newModule.id;
@@ -449,7 +447,7 @@ $effect(() => {
     return cleanup;
 });
 $effect(() => {
-    const cleanup = aiChatManager.listenForSelectedIdChanges($selectedId, flowStore.val, $flowStateStore, $currentEditor);
+    const cleanup = aiChatManager.listenForSelectedIdChanges($selectedId, flowStore.val, flowStateStore.val, $currentEditor);
     return cleanup;
 });
 $effect(() => {