windmill-components 1.677.1 → 1.695.0

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

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import { collectAllFlowModuleIdsFromModules } from '../../../../components/flows/flowTree';
+function createAiAgentTool(id, content) {
+    return {
+        id,
+        summary: id,
+        value: {
+            tool_type: 'flowmodule',
+            type: 'rawscript',
+            content,
+            language: 'bun',
+            input_transforms: {}
+        }
+    };
+}
+function createAiAgentModule(id, tools) {
+    return {
+        id,
+        value: {
+            type: 'aiagent',
+            tools,
+            input_transforms: {}
+        }
+    };
+}
+describe('chat flow utils', () => {
+    it('collects nested module ids and all ai agent tool ids for flow-json validation', () => {
+        const modules = [
+            {
+                id: 'router',
+                value: {
+                    type: 'branchone',
+                    default: [{ id: 'default_step', value: { type: 'identity' } }],
+                    branches: [{ expr: 'true', modules: [{ id: 'branch_step', value: { type: 'identity' } }] }],
+                    input_transforms: {}
+                }
+            },
+            createAiAgentModule('agent', [
+                createAiAgentTool('lookup', 'lookup-tool'),
+                {
+                    id: 'search_docs',
+                    summary: 'search_docs',
+                    value: {
+                        tool_type: 'mcp',
+                        resource_path: ''
+                    }
+                }
+            ])
+        ];
+        expect(collectAllFlowModuleIdsFromModules(modules)).toEqual([
+            'router',
+            'branch_step',
+            'default_step',
+            'agent',
+            'lookup',
+            'search_docs'
+        ]);
+    });
+});

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

@@ -3,6 +3,11 @@ 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';
+import { type ChatTokenUsage } from './tokenUsage';
+interface ParsedCompletionResult {
+    shouldContinue: boolean;
+    tokenUsage: ChatTokenUsage;
+}
 export declare function getOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[], options?: {
     forceModelProvider?: AIProviderModel;
     openaiClient?: OpenAI;
@@ -13,10 +18,11 @@ export declare function parseOpenAIResponsesCompletion(runner: ResponseStream, c
     onMessageEnd: () => void;
 }, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, options?: {
     workspace?: string;
-}): Promise<boolean>;
+}): Promise<ParsedCompletionResult>;
 export declare function getNonStreamingOpenAIResponsesCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, testOptions?: {
     apiKey?: string;
     workspace?: string;
     resourcePath?: string;
     forceModelProvider: AIProviderModel;
 }): Promise<string>;
+export {};

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

@@ -1,6 +1,7 @@
 import OpenAI, { OpenAIError } from 'openai';
 import { createOpenAIProxyClient, getAiProxyBaseURL, getProviderAndCompletionConfig, workspaceAIClients } from '../lib';
 import { processToolCall } from './shared';
+import { openAIResponsesUsageToChatTokenUsage } from './tokenUsage';
 // Conversion utilities for Responses API
 function convertMessagesToResponsesInput(messages) {
     const systemMessage = messages.find((m) => m.role === 'system');
@@ -254,6 +255,8 @@ export async function parseOpenAIResponsesCompletion(runner, callbacks, messages
     if (error) {
         throw error;
     }
+    const finalResponse = await runner.finalResponse();
+    const tokenUsage = openAIResponsesUsageToChatTokenUsage(finalResponse.usage);
     // Process tool calls if any
     if (toolCallsToProcess.length > 0) {
         const assistantWithTools = {
@@ -274,9 +277,9 @@ export async function parseOpenAIResponsesCompletion(runner, callbacks, messages
             messages.push(messageToAdd);
             addedMessages.push(messageToAdd);
         }
-        return true; // Continue the conversation loop
+        return { shouldContinue: true, tokenUsage };
     }
-    return false; // End the conversation
+    return { shouldContinue: false, tokenUsage };
 }
 export async function getNonStreamingOpenAIResponsesCompletion(messages, abortController, testOptions) {
     const { provider, config } = getProviderAndCompletionConfig({

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

@@ -4,6 +4,7 @@ import { get } from 'svelte/store';
 import { compile, phpCompile, pythonCompile } from '../../utils';
 import { dbSchemas } from '../../../../stores';
 import { createSearchHubScriptsTool, executeTestRun, buildTestRunArgs, buildContextString, formatScriptLintResult, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
+import { createWorkspaceMutationTools } from '../workspaceTools';
 import { setupTypeAcquisition } from '../../../../ata';
 import { getModelContextWindow } from '../../lib';
 import { getCurrentModel } from '../../../../aiStore';
@@ -131,6 +132,7 @@ function buildChatSystemPrompt(currentModel) {
 	- Before giving your answer, check again that you carefully followed these instructions.
 	- 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.
 	- Use \`search_workspace\` to find existing scripts and flows in the workspace, and \`get_runnable_details\` to inspect their schema and code. This is useful when the user wants to reference or reuse existing workspace runnables.
+	- Use \`create_schedule\` or \`create_trigger\` when the user asks to create a schedule or trigger for the current script.
 	- After applying code changes with the \`${editToolName}\` tool, ALWAYS use the \`get_lint_errors\` tool to check for lint errors. If there are errors, fix them before proceeding. Then 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.
 
 	Important:
@@ -268,6 +270,7 @@ export function prepareScriptTools(currentModel, language, context) {
     tools.push(getLintErrorsTool);
     tools.push(createSearchWorkspaceTool());
     tools.push(createGetRunnableDetailsTool());
+    tools.push(...createWorkspaceMutationTools());
     return tools;
 }
 export function prepareScriptUserMessage(instructions, selectedContext) {

package/package/components/copilot/chat/shared.d.ts

@@ -26,8 +26,7 @@ export interface ContextStringResult {
     hasFlowModule: boolean;
 }
 export declare const extractAllModules: (modules: FlowModule[]) => FlowModule[];
-export declare const findModuleById: (modules: FlowModule[], moduleId: string) => FlowModule | undefined;
-export declare function applyCodePiecesToFlowModules(codePieces: FlowModuleCodePieceElement[], flowModules: FlowModule[]): string;
+export declare function applyCodePiecesToFlowModules(codePieces: FlowModuleCodePieceElement[], flowModules: FlowModule[]): FlowModule[];
 export declare function buildContextString(selectedContext: ContextElement[]): string;
 type BaseDisplayMessage = {
     content: string;
@@ -64,6 +63,7 @@ export type AssistantDisplayMessage = BaseDisplayMessage & {
     role: 'assistant';
 };
 export type DisplayMessage = UserDisplayMessage | ToolDisplayMessage | AssistantDisplayMessage;
+type MaybePromise<T> = T | Promise<T>;
 export declare function processToolCall<T>({ tools, toolCall, helpers, toolCallbacks, workspace }: {
     tools: Tool<T>[];
     toolCall: ChatCompletionMessageFunctionToolCall;
@@ -84,6 +84,11 @@ export interface Tool<T> {
         toolCallbacks: ToolCallbacks;
         toolId: string;
     }) => void;
+    validateBeforeConfirmation?: (p: {
+        args: any;
+        workspace: string;
+        helpers: T;
+    }) => MaybePromise<string | undefined>;
     setSchema?: (helpers: any) => Promise<void>;
     requiresConfirmation?: boolean;
     confirmationMessage?: string;

package/package/components/copilot/chat/shared.js

@@ -11,6 +11,7 @@ export const SPECIAL_MODULE_IDS = {
 };
 import { get } from 'svelte/store';
 import { workspaceStore } from '../../../stores';
+import { findModuleInModules } from '../../flows/flowTree';
 import { z } from 'zod';
 import { ScriptService, FlowService, JobService } from '../../../gen';
 import uFuzzy from '@leeoniya/ufuzzy';
@@ -45,6 +46,51 @@ function prettifyCodeArguments(content) {
     codeContent = codeContent.replace(/\\\\/g, '\\');
     return codeContent;
 }
+function decodeEscapedToolString(content) {
+    return content
+        .replace(/\\n/g, '\n')
+        .replace(/\\t/g, '\t')
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+function extractJsonStringProperty(content, property) {
+    const propertyKey = `"${property}"`;
+    const propertyIndex = content.indexOf(propertyKey);
+    if (propertyIndex === -1) {
+        return undefined;
+    }
+    let cursor = propertyIndex + propertyKey.length;
+    while (cursor < content.length && /\s/.test(content[cursor] ?? '')) {
+        cursor++;
+    }
+    if (content[cursor] !== ':') {
+        return undefined;
+    }
+    cursor++;
+    while (cursor < content.length && /\s/.test(content[cursor] ?? '')) {
+        cursor++;
+    }
+    if (content[cursor] !== '"') {
+        return undefined;
+    }
+    const start = cursor + 1;
+    let escaped = false;
+    for (let index = start; index < content.length; index++) {
+        const char = content[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            return content.slice(start, index);
+        }
+    }
+    return content.slice(start);
+}
 // Prettify function for set_module_code - extracts code from moduleId/code JSON
 function prettifySetModuleCode(content) {
     let codeContent = content;
@@ -56,19 +102,37 @@ function prettifySetModuleCode(content) {
             }
         }
         catch {
-            // If JSON is incomplete during streaming, try to extract code property manually
-            const codeMatch = content.match(/"code"\s*:\s*"([\s\S]*?)(?:"\s*}?\s*$|$)/);
-            if (codeMatch) {
-                codeContent = codeMatch[1];
+            const extractedCode = extractJsonStringProperty(content, 'code');
+            if (extractedCode !== undefined) {
+                codeContent = extractedCode;
             }
         }
     }
-    // Convert escape sequences
-    codeContent = codeContent.replace(/\\n/g, '\n');
-    codeContent = codeContent.replace(/\\t/g, '\t');
-    codeContent = codeContent.replace(/\\"/g, '"');
-    codeContent = codeContent.replace(/\\\\/g, '\\');
-    return codeContent;
+    return decodeEscapedToolString(codeContent);
+}
+function prettifyPatchReplacement(content) {
+    let newString;
+    if (typeof content === 'string' && content.trim().startsWith('{')) {
+        try {
+            const parsed = JSON.parse(content);
+            if (typeof parsed.new_string === 'string') {
+                newString = parsed.new_string;
+            }
+        }
+        catch {
+            newString = extractJsonStringProperty(content, 'new_string');
+        }
+    }
+    if (newString === undefined) {
+        return content;
+    }
+    return decodeEscapedToolString(newString);
+}
+function prettifyPatchFlowJson(content) {
+    return prettifyPatchReplacement(content);
+}
+function prettifyPatchFile(content) {
+    return prettifyPatchReplacement(content);
 }
 // Prettify function for module value JSON - extracts the 'value' property and formats it
 function prettifyModuleValue(content) {
@@ -128,6 +192,8 @@ function prettifyModuleValue(content) {
 export const TOOL_PRETTIFY_MAP = {
     edit_code: prettifyCodeArguments,
     set_module_code: prettifySetModuleCode,
+    patch_flow_json: prettifyPatchFlowJson,
+    patch_file: prettifyPatchFile,
     add_module: prettifyModuleValue,
     modify_module: prettifyModuleValue
 };
@@ -148,37 +214,6 @@ export const extractAllModules = (modules) => {
         return [m];
     });
 };
-export const findModuleById = (modules, moduleId) => {
-    for (const module of modules) {
-        if (module.id === moduleId) {
-            return module;
-        }
-        if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-            const found = findModuleById(module.value.modules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-        if (module.value.type === 'branchall') {
-            const allModules = module.value.branches.flatMap((b) => b.modules);
-            const found = findModuleById(allModules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-        if (module.value.type === 'branchone') {
-            const allModules = [
-                ...module.value.branches.flatMap((b) => b.modules),
-                ...module.value.default
-            ];
-            const found = findModuleById(allModules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-    }
-    return undefined;
-};
 const applyCodePieceToCodeContext = (codePieces, codeContext) => {
     let code = codeContext.split('\n');
     let shiftOffset = 0;
@@ -203,12 +238,12 @@ export function applyCodePiecesToFlowModules(codePieces, flowModules) {
     const modifiedModules = JSON.parse(JSON.stringify(flowModules));
     // Apply code pieces to each module
     for (const [moduleId, pieces] of moduleCodePieces) {
-        const module = findModuleById(modifiedModules, moduleId);
+        const module = findModuleInModules(modifiedModules, moduleId);
         if (module && module.value.type === 'rawscript' && module.value.content) {
             module.value.content = applyCodePieceToCodeContext(pieces, module.value.content);
         }
     }
-    return JSON.stringify(modifiedModules, null, 2);
+    return modifiedModules;
 }
 export function buildContextString(selectedContext) {
     const dbTemplate = `- {title}: SCHEMA: \n{schema}\n`;
@@ -314,6 +349,27 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks,
     try {
         const args = JSON.parse(toolCall.function.arguments || '{}');
         const tool = tools.find((t) => t.def.function.name === toolCall.function.name);
+        const workspaceId = workspace ?? get(workspaceStore) ?? '';
+        const validationError = await tool?.validateBeforeConfirmation?.({
+            args,
+            workspace: workspaceId,
+            helpers
+        });
+        if (validationError) {
+            toolCallbacks.setToolStatus(toolCall.id, {
+                content: validationError,
+                parameters: args,
+                isLoading: false,
+                error: validationError,
+                needsConfirmation: false,
+                showDetails: tool?.showDetails
+            });
+            return {
+                role: 'tool',
+                tool_call_id: toolCall.id,
+                content: validationError
+            };
+        }
         // Check if tool requires confirmation
         const needsConfirmation = tool?.requiresConfirmation;
         toolCallbacks.setToolStatus(toolCall.id, {
@@ -353,7 +409,7 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks,
                 tools,
                 functionName: toolCall.function.name,
                 args,
-                workspace: workspace ?? get(workspaceStore) ?? '',
+                workspace: workspaceId,
                 helpers,
                 toolCallbacks,
                 toolId: toolCall.id
@@ -398,6 +454,7 @@ export function createToolDef(zodSchema, name, description, { strict = true } =
     delete parameters.$schema;
     if (!parameters.required)
         parameters.required = [];
+    normalizeToolParameterSchema(parameters);
     return {
         type: 'function',
         function: {
@@ -446,9 +503,9 @@ export const createSearchHubScriptsTool = (withContent = false) => ({
     }
 });
 /**
- * Recursively removes format: null or format: '' from a JSON schema object
+ * Recursively normalizes JSON Schema quirks that specific providers reject.
  */
-function removeNullFormats(schema) {
+function normalizeToolParameterSchema(schema) {
     if (!schema || typeof schema !== 'object') {
         return;
     }
@@ -459,22 +516,29 @@ function removeNullFormats(schema) {
     // Recurse into properties
     if (schema.properties && typeof schema.properties === 'object') {
         for (const key of Object.keys(schema.properties)) {
-            removeNullFormats(schema.properties[key]);
+            normalizeToolParameterSchema(schema.properties[key]);
         }
     }
     // Recurse into items (for arrays)
     if (schema.items) {
-        removeNullFormats(schema.items);
+        if (Array.isArray(schema.items)) {
+            for (const item of schema.items) {
+                normalizeToolParameterSchema(item);
+            }
+        }
+        else {
+            normalizeToolParameterSchema(schema.items);
+        }
     }
     // Recurse into additionalProperties if it's an object schema
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        removeNullFormats(schema.additionalProperties);
+        normalizeToolParameterSchema(schema.additionalProperties);
     }
     // Recurse into allOf, anyOf, oneOf
     for (const key of ['allOf', 'anyOf', 'oneOf']) {
         if (Array.isArray(schema[key])) {
             for (const subSchema of schema[key]) {
-                removeNullFormats(subSchema);
+                normalizeToolParameterSchema(subSchema);
             }
         }
     }
@@ -489,8 +553,8 @@ export async function buildSchemaForTool(toolDef, schemaBuilder) {
             throw new Error(`Invalid flow inputs schema: ${invalidProperties.join(', ')}`);
         }
         toolDef.function.parameters = { ...schema, additionalProperties: false };
-        // recursively remove any format: null or format: '' (empty string) from schema
-        removeNullFormats(toolDef.function.parameters);
+        // recursively normalize provider-incompatible schema fragments
+        normalizeToolParameterSchema(toolDef.function.parameters);
         // OPEN AI models don't support strict mode well with schema with complex properties, so we disable it
         const model = getCurrentModel();
         if (model.provider === 'openai' || model.provider === 'azure_openai') {
@@ -689,7 +753,6 @@ export function formatScriptLintResult(lintResult) {
     }
     return response;
 }
-// ============= Workspace Runnables Search =============
 export class WorkspaceRunnablesSearch {
     uf;
     scriptsWorkspace = undefined;

package/package/components/copilot/chat/shared.test.d.ts

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