windmill-components 1.677.0 → 1.687.0

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

@@ -0,0 +1,19 @@
+import type { FlowModule, OpenFlow, RawScript } from '../../../../gen';
+import type { InlineScriptSession } from './inlineScriptsUtils';
+type FlowLike = Pick<OpenFlow, 'value'> & {
+    schema?: Record<string, any>;
+};
+export interface FlowJsonUpdate {
+    modules?: FlowModule[];
+    schema?: Record<string, any> | null;
+    preprocessorModule?: FlowModule | null;
+    failureModule?: FlowModule | null;
+}
+export interface FlowJsonUpdateResult {
+    emptyInlineScriptModuleIds: string[];
+}
+export declare function updateRawScriptModuleContent(flow: FlowLike, id: string, code: string): (FlowModule & {
+    value: RawScript;
+}) | undefined;
+export declare function applyFlowJsonUpdate(flow: FlowLike, inlineScriptSession: InlineScriptSession, { modules, schema, preprocessorModule, failureModule }: FlowJsonUpdate): FlowJsonUpdateResult;
+export {};

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

@@ -0,0 +1,68 @@
+import { forEachFlowModule } from '../../../flows/dfs';
+import { findModuleInFlow } from '../../../flows/flowTree';
+export function updateRawScriptModuleContent(flow, id, code) {
+    const module = findModuleInFlow(flow.value, id);
+    if (!module || module.value.type !== 'rawscript') {
+        return undefined;
+    }
+    const rawScriptModule = module;
+    rawScriptModule.value.content = code;
+    return rawScriptModule;
+}
+export function applyFlowJsonUpdate(flow, inlineScriptSession, { modules, schema, preprocessorModule, failureModule }) {
+    const emptyInlineScriptModuleIds = new Set();
+    if (modules !== undefined) {
+        flow.value.modules = restoreFlowModules(modules, inlineScriptSession, emptyInlineScriptModuleIds);
+    }
+    if (schema !== undefined) {
+        flow.schema = schema ?? undefined;
+    }
+    if (preprocessorModule !== undefined) {
+        flow.value.preprocessor_module =
+            preprocessorModule === null
+                ? undefined
+                : restoreFlowModule(preprocessorModule, inlineScriptSession, emptyInlineScriptModuleIds);
+    }
+    if (failureModule !== undefined) {
+        flow.value.failure_module =
+            failureModule === null
+                ? undefined
+                : restoreFlowModule(failureModule, inlineScriptSession, emptyInlineScriptModuleIds);
+    }
+    return {
+        emptyInlineScriptModuleIds: Array.from(emptyInlineScriptModuleIds)
+    };
+}
+function restoreFlowModules(modules, inlineScriptSession, emptyInlineScriptModuleIds) {
+    const restoredModules = inlineScriptSession.restoreInlineScriptReferences(modules);
+    replaceNewInlineScriptRefsWithEmptyCode(restoredModules, emptyInlineScriptModuleIds);
+    assertResolvedInlineScripts(restoredModules, inlineScriptSession);
+    return restoredModules;
+}
+function restoreFlowModule(module, inlineScriptSession, emptyInlineScriptModuleIds) {
+    const [restoredModule] = inlineScriptSession.restoreInlineScriptReferences([module]);
+    replaceNewInlineScriptRefsWithEmptyCode([restoredModule], emptyInlineScriptModuleIds);
+    assertResolvedInlineScripts([restoredModule], inlineScriptSession);
+    return restoredModule;
+}
+function assertResolvedInlineScripts(modules, inlineScriptSession) {
+    const unresolvedRefs = inlineScriptSession.findUnresolvedInlineScriptRefs(modules);
+    if (unresolvedRefs.length > 0) {
+        throw new Error(`Unresolved inline script references: ${unresolvedRefs.join(', ')}`);
+    }
+}
+function replaceNewInlineScriptRefsWithEmptyCode(modules, emptyInlineScriptModuleIds) {
+    function replaceInlineScriptRefWithEmptyCode(ownerId, content) {
+        const match = content.match(/^inline_script\.(.+)$/);
+        if (!match || match[1] !== ownerId) {
+            return content;
+        }
+        emptyInlineScriptModuleIds.add(ownerId);
+        return '';
+    }
+    forEachFlowModule(modules, (module) => {
+        if (module.value.type === 'rawscript' && module.value.content) {
+            module.value.content = replaceInlineScriptRefWithEmptyCode(module.id, module.value.content);
+        }
+    });
+}

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

@@ -0,0 +1,116 @@
+import { describe, expect, it, vi } from 'vitest';
+import { applyFlowJsonUpdate, updateRawScriptModuleContent } from './helperUtils';
+import { createInlineScriptSession } from './inlineScriptsUtils';
+vi.mock('../shared', () => ({
+    SPECIAL_MODULE_IDS: {
+        PREPROCESSOR: 'preprocessor',
+        FAILURE: 'failure'
+    }
+}));
+function makeRawScriptModule(id, content) {
+    return {
+        id,
+        summary: id,
+        value: {
+            type: 'rawscript',
+            language: 'bun',
+            content,
+            input_transforms: {}
+        }
+    };
+}
+function makeAiAgentWithTool(agentId, toolId, toolContent) {
+    return {
+        id: agentId,
+        summary: agentId,
+        value: {
+            type: 'aiagent',
+            tools: [
+                {
+                    id: toolId,
+                    summary: toolId,
+                    value: {
+                        tool_type: 'flowmodule',
+                        type: 'rawscript',
+                        language: 'bun',
+                        content: toolContent,
+                        input_transforms: {}
+                    }
+                }
+            ],
+            input_transforms: {}
+        }
+    };
+}
+describe('applyFlowJsonUpdate', () => {
+    it('accepts new self-referenced inline scripts and initializes them as empty', () => {
+        const flow = {
+            value: {
+                modules: [makeRawScriptModule('process_data', 'existing code')]
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        inlineScriptSession.set('process_data', 'existing code');
+        const result = applyFlowJsonUpdate(flow, inlineScriptSession, {
+            modules: [
+                makeRawScriptModule('process_data', 'inline_script.process_data'),
+                makeRawScriptModule('validate_data', 'inline_script.validate_data')
+            ]
+        });
+        const [processDataModule, validateDataModule] = flow.value.modules;
+        expect(result.emptyInlineScriptModuleIds).toEqual(['validate_data']);
+        expect(inlineScriptSession.has('validate_data')).toBe(false);
+        expect(processDataModule?.value.type).toBe('rawscript');
+        expect(processDataModule?.value.content).toBe('existing code');
+        expect(validateDataModule?.value.type).toBe('rawscript');
+        expect(validateDataModule?.value.content).toBe('');
+    });
+    it('still rejects unresolved inline script references that do not match the module id', () => {
+        const flow = {
+            value: {
+                modules: []
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        expect(() => applyFlowJsonUpdate(flow, inlineScriptSession, {
+            modules: [makeRawScriptModule('validate_data', 'inline_script.other_module')]
+        })).toThrow('Unresolved inline script references: other_module');
+    });
+    it('keeps the inline script session unchanged after a failed update so retries still warn', () => {
+        const flow = {
+            value: {
+                modules: [makeRawScriptModule('process_data', 'existing code')]
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        inlineScriptSession.set('process_data', 'existing code');
+        expect(() => applyFlowJsonUpdate(flow, inlineScriptSession, {
+            modules: [
+                makeRawScriptModule('validate_data', 'inline_script.validate_data'),
+                makeRawScriptModule('save_results', 'inline_script.other_module')
+            ]
+        })).toThrow('Unresolved inline script references: other_module');
+        expect(inlineScriptSession.getAll()).toEqual({
+            process_data: 'existing code'
+        });
+        expect(flow.value.modules[0]?.value.content).toBe('existing code');
+        const result = applyFlowJsonUpdate(flow, inlineScriptSession, {
+            modules: [
+                makeRawScriptModule('process_data', 'inline_script.process_data'),
+                makeRawScriptModule('validate_data', 'inline_script.validate_data')
+            ]
+        });
+        expect(result.emptyInlineScriptModuleIds).toEqual(['validate_data']);
+        expect(inlineScriptSession.has('validate_data')).toBe(false);
+    });
+    it('updates ai agent rawscript tools in place when changing module code', () => {
+        const flow = {
+            value: {
+                modules: [makeAiAgentWithTool('agent', 'sum', '')]
+            }
+        };
+        const updatedModule = updateRawScriptModuleContent(flow, 'sum', 'export async function main(numbers: number[]) { return 0 }');
+        expect(updatedModule?.value.content).toBe('export async function main(numbers: number[]) { return 0 }');
+        expect(flow.value.modules[0].value.tools[0].value.content).toBe('export async function main(numbers: number[]) { return 0 }');
+    });
+});

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

@@ -1,31 +1,12 @@
 import type { FlowModule } from '../../../../gen';
-/**
- * Storage for inline scripts extracted from flow modules.
- * Maps module IDs to their rawscript content for token-efficient transmission to AI.
- */
-declare class InlineScriptStore {
-    private scripts;
+export interface InlineScriptSession {
     clear(): void;
     set(moduleId: string, content: string): void;
     get(moduleId: string): string | undefined;
     has(moduleId: string): boolean;
     getAll(): Record<string, string>;
+    extractAndReplaceInlineScripts(modules: FlowModule[]): FlowModule[];
+    restoreInlineScriptReferences(modules: FlowModule[]): FlowModule[];
+    findUnresolvedInlineScriptRefs(modules: FlowModule[]): string[];
 }
-export declare const inlineScriptStore: InlineScriptStore;
-/**
- * Recursively extracts all rawscript content from flow modules and stores them.
- * Replaces the content with references like "inline_script.{module_id}".
- */
-export declare function extractAndReplaceInlineScripts(modules: FlowModule[]): FlowModule[];
-/**
- * Recursively restores inline script references back to their full content.
- * If content matches pattern "inline_script.{id}", looks up and restores the original.
- * If content doesn't match (new/modified script), keeps it as-is.
- */
-export declare function restoreInlineScriptReferences(modules: FlowModule[]): FlowModule[];
-/**
- * Recursively finds any unresolved inline script references in flow modules.
- * Returns array of module IDs that still have `inline_script.{id}` patterns.
- */
-export declare function findUnresolvedInlineScriptRefs(modules: FlowModule[]): string[];
-export {};
+export declare function createInlineScriptSession(): InlineScriptSession;

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

@@ -1,8 +1,4 @@
-/**
- * Storage for inline scripts extracted from flow modules.
- * Maps module IDs to their rawscript content for token-efficient transmission to AI.
- */
-class InlineScriptStore {
+class DefaultInlineScriptSession {
     scripts = new Map();
     clear() {
         this.scripts.clear();
@@ -19,68 +15,69 @@ class InlineScriptStore {
     getAll() {
         return Object.fromEntries(this.scripts.entries());
     }
+    extractAndReplaceInlineScripts(modules) {
+        return extractAndReplaceInlineScripts(modules, this);
+    }
+    restoreInlineScriptReferences(modules) {
+        return restoreInlineScriptReferences(modules, this);
+    }
+    findUnresolvedInlineScriptRefs(modules) {
+        return findUnresolvedInlineScriptRefs(modules);
+    }
+}
+export function createInlineScriptSession() {
+    return new DefaultInlineScriptSession();
 }
-export const inlineScriptStore = new InlineScriptStore();
-/**
- * Recursively extracts all rawscript content from flow modules and stores them.
- * Replaces the content with references like "inline_script.{module_id}".
- */
-export function extractAndReplaceInlineScripts(modules) {
+function extractAndReplaceInlineScripts(modules, session) {
     if (!modules || !Array.isArray(modules)) {
         return [];
     }
     return modules.map((module) => {
         const newModule = { ...module };
         if (newModule.value.type === 'rawscript' && newModule.value.content) {
-            // Store the original content
-            inlineScriptStore.set(module.id, newModule.value.content);
-            // Replace with reference
+            session.set(module.id, newModule.value.content);
             newModule.value = {
                 ...newModule.value,
                 content: `inline_script.${module.id}`
             };
         }
         else if (newModule.value.type === 'forloopflow' || newModule.value.type === 'whileloopflow') {
-            // Recursively process nested modules in loops
             if (newModule.value.modules) {
                 newModule.value = {
                     ...newModule.value,
-                    modules: extractAndReplaceInlineScripts(newModule.value.modules)
+                    modules: extractAndReplaceInlineScripts(newModule.value.modules, session)
                 };
             }
         }
         else if (newModule.value.type === 'branchone') {
-            // Process branches and default modules
             if (newModule.value.branches) {
                 newModule.value = {
                     ...newModule.value,
                     branches: newModule.value.branches.map((branch) => ({
                         ...branch,
-                        modules: branch.modules ? extractAndReplaceInlineScripts(branch.modules) : []
+                        modules: branch.modules ? extractAndReplaceInlineScripts(branch.modules, session) : []
                     }))
                 };
             }
             if (newModule.value.default) {
                 newModule.value = {
                     ...newModule.value,
-                    default: extractAndReplaceInlineScripts(newModule.value.default)
+                    default: extractAndReplaceInlineScripts(newModule.value.default, session)
                 };
             }
         }
         else if (newModule.value.type === 'branchall') {
-            // Process all branches
             if (newModule.value.branches) {
                 newModule.value = {
                     ...newModule.value,
                     branches: newModule.value.branches.map((branch) => ({
                         ...branch,
-                        modules: branch.modules ? extractAndReplaceInlineScripts(branch.modules) : []
+                        modules: branch.modules ? extractAndReplaceInlineScripts(branch.modules, session) : []
                     }))
                 };
             }
         }
         else if (newModule.value.type === 'aiagent') {
-            // Process AI agent tools
             if (newModule.value.tools) {
                 newModule.value = {
                     ...newModule.value,
@@ -92,7 +89,7 @@ export function extractAndReplaceInlineScripts(modules) {
                             tool.value.type === 'rawscript' &&
                             'content' in tool.value &&
                             tool.value.content) {
-                            inlineScriptStore.set(tool.id, tool.value.content);
+                            session.set(tool.id, tool.value.content);
                             return {
                                 ...tool,
                                 value: {
@@ -109,73 +106,58 @@ export function extractAndReplaceInlineScripts(modules) {
         return newModule;
     });
 }
-/**
- * Recursively restores inline script references back to their full content.
- * If content matches pattern "inline_script.{id}", looks up and restores the original.
- * If content doesn't match (new/modified script), keeps it as-is.
- */
-export function restoreInlineScriptReferences(modules) {
+function restoreInlineScriptReferences(modules, session) {
     return modules.map((module) => {
         const newModule = { ...module };
         if (newModule.value.type === 'rawscript' && newModule.value.content) {
-            const content = newModule.value.content;
-            // Check if it's a reference
-            const match = content.match(/^inline_script\.(.+)$/);
+            const match = newModule.value.content.match(/^inline_script\.(.+)$/);
             if (match) {
-                const moduleId = match[1];
-                const storedContent = inlineScriptStore.get(moduleId);
+                const storedContent = session.get(match[1]);
                 if (storedContent !== undefined) {
-                    // Restore original content
                     newModule.value = {
                         ...newModule.value,
                         content: storedContent
                     };
                 }
-                // If not found in store, keep the reference as-is (shouldn't happen normally)
             }
-            // If not a reference, it's new/modified content - keep as-is
         }
         else if (newModule.value.type === 'forloopflow' || newModule.value.type === 'whileloopflow') {
-            // Recursively process nested modules in loops
             if (newModule.value.modules) {
                 newModule.value = {
                     ...newModule.value,
-                    modules: restoreInlineScriptReferences(newModule.value.modules)
+                    modules: restoreInlineScriptReferences(newModule.value.modules, session)
                 };
             }
         }
         else if (newModule.value.type === 'branchone') {
-            // Process branches and default modules
             if (newModule.value.branches) {
                 newModule.value = {
                     ...newModule.value,
                     branches: newModule.value.branches.map((branch) => ({
                         ...branch,
-                        modules: branch.modules ? restoreInlineScriptReferences(branch.modules) : []
+                        modules: branch.modules ? restoreInlineScriptReferences(branch.modules, session) : []
                     }))
                 };
             }
             if (newModule.value.default) {
                 newModule.value = {
                     ...newModule.value,
-                    default: restoreInlineScriptReferences(newModule.value.default)
+                    default: restoreInlineScriptReferences(newModule.value.default, session)
                 };
             }
         }
         else if (newModule.value.type === 'branchall') {
-            // Process all branches
             if (newModule.value.branches) {
                 newModule.value = {
                     ...newModule.value,
                     branches: newModule.value.branches.map((branch) => ({
                         ...branch,
-                        modules: branch.modules ? restoreInlineScriptReferences(branch.modules) : []
+                        modules: branch.modules ? restoreInlineScriptReferences(branch.modules, session) : []
                     }))
                 };
             }
         }
         else if (newModule.value.type === 'aiagent') {
-            // Process AI agent tools
             if (newModule.value.tools) {
                 newModule.value = {
                     ...newModule.value,
@@ -187,11 +169,9 @@ export function restoreInlineScriptReferences(modules) {
                             tool.value.type === 'rawscript' &&
                             'content' in tool.value &&
                             tool.value.content) {
-                            const content = tool.value.content;
-                            const match = content.match(/^inline_script\.(.+)$/);
+                            const match = tool.value.content.match(/^inline_script\.(.+)$/);
                             if (match) {
-                                const toolId = match[1];
-                                const storedContent = inlineScriptStore.get(toolId);
+                                const storedContent = session.get(match[1]);
                                 if (storedContent !== undefined) {
                                     return {
                                         ...tool,
@@ -211,11 +191,7 @@ export function restoreInlineScriptReferences(modules) {
         return newModule;
     });
 }
-/**
- * Recursively finds any unresolved inline script references in flow modules.
- * Returns array of module IDs that still have `inline_script.{id}` patterns.
- */
-export function findUnresolvedInlineScriptRefs(modules) {
+function findUnresolvedInlineScriptRefs(modules) {
     const unresolvedRefs = [];
     function checkModule(module) {
         if (module.value.type === 'rawscript' && module.value.content) {
@@ -247,7 +223,6 @@ export function findUnresolvedInlineScriptRefs(modules) {
             }
         }
         else if (module.value.type === 'aiagent') {
-            // Check AI agent tools
             if (module.value.tools) {
                 for (const tool of module.value.tools) {
                     if (tool.value &&

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/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;