windmill-components 1.677.1 → 1.695.0

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

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

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

@@ -0,0 +1,100 @@
+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 validateFlowGroups(rawGroups, moduleIds) {
+    if (rawGroups == null) {
+        return null;
+    }
+    if (!Array.isArray(rawGroups)) {
+        throw new Error('Flow groups must be an array');
+    }
+    return rawGroups.map((group, index) => {
+        if (!group || typeof group !== 'object' || Array.isArray(group)) {
+            throw new Error(`Invalid group at index ${index}: must be an object`);
+        }
+        const g = group;
+        if (typeof g.start_id !== 'string' || !g.start_id) {
+            throw new Error(`Invalid group at index ${index}: start_id must be a non-empty string`);
+        }
+        if (typeof g.end_id !== 'string' || !g.end_id) {
+            throw new Error(`Invalid group at index ${index}: end_id must be a non-empty string`);
+        }
+        if (moduleIds) {
+            if (!moduleIds.has(g.start_id)) {
+                throw new Error(`Invalid group at index ${index}: start_id "${g.start_id}" does not match any flow module`);
+            }
+            if (!moduleIds.has(g.end_id)) {
+                throw new Error(`Invalid group at index ${index}: end_id "${g.end_id}" does not match any flow module`);
+            }
+        }
+        return g;
+    });
+}
+export function applyFlowJsonUpdate(flow, inlineScriptSession, { modules, schema, preprocessorModule, failureModule, groups }) {
+    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);
+    }
+    if (groups !== undefined) {
+        flow.value.groups = groups == null || groups.length === 0 ? undefined : groups;
+    }
+    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,231 @@
+import { describe, expect, it, vi } from 'vitest';
+import { applyFlowJsonUpdate, updateRawScriptModuleContent, validateFlowGroups } 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('persists groups passed in the flow json update', () => {
+        const flow = {
+            value: {
+                modules: [
+                    makeRawScriptModule('fetch_data', 'existing code'),
+                    makeRawScriptModule('process_data', 'existing code')
+                ]
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        inlineScriptSession.set('fetch_data', 'existing code');
+        inlineScriptSession.set('process_data', 'existing code');
+        applyFlowJsonUpdate(flow, inlineScriptSession, {
+            groups: [
+                {
+                    summary: 'Data Ingestion',
+                    note: 'Fetches and processes data',
+                    start_id: 'fetch_data',
+                    end_id: 'process_data'
+                }
+            ]
+        });
+        expect(flow.value.groups).toEqual([
+            {
+                summary: 'Data Ingestion',
+                note: 'Fetches and processes data',
+                start_id: 'fetch_data',
+                end_id: 'process_data'
+            }
+        ]);
+    });
+    it('clears groups when an empty array is passed', () => {
+        const flow = {
+            value: {
+                modules: [],
+                groups: [
+                    {
+                        summary: 'existing',
+                        start_id: 'a',
+                        end_id: 'b'
+                    }
+                ]
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        applyFlowJsonUpdate(flow, inlineScriptSession, { groups: [] });
+        expect(flow.value.groups).toBeUndefined();
+    });
+    it('clears groups when null is passed', () => {
+        const flow = {
+            value: {
+                modules: [],
+                groups: [
+                    {
+                        summary: 'existing',
+                        start_id: 'a',
+                        end_id: 'b'
+                    }
+                ]
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        applyFlowJsonUpdate(flow, inlineScriptSession, { groups: null });
+        expect(flow.value.groups).toBeUndefined();
+    });
+    it('leaves groups untouched when not provided in the update', () => {
+        const existingGroups = [{ summary: 'existing', start_id: 'a', end_id: 'b' }];
+        const flow = {
+            value: {
+                modules: [makeRawScriptModule('a', 'existing code')],
+                groups: existingGroups
+            }
+        };
+        const inlineScriptSession = createInlineScriptSession();
+        inlineScriptSession.set('a', 'existing code');
+        applyFlowJsonUpdate(flow, inlineScriptSession, {
+            modules: [makeRawScriptModule('a', 'inline_script.a')]
+        });
+        expect(flow.value.groups).toEqual(existingGroups);
+    });
+    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 }');
+    });
+});
+describe('validateFlowGroups', () => {
+    it('returns null for null input', () => {
+        expect(validateFlowGroups(null)).toBeNull();
+        expect(validateFlowGroups(undefined)).toBeNull();
+    });
+    it('rejects non-array input', () => {
+        expect(() => validateFlowGroups({})).toThrow('Flow groups must be an array');
+        expect(() => validateFlowGroups('not an array')).toThrow('Flow groups must be an array');
+    });
+    it('rejects a group that is not an object', () => {
+        expect(() => validateFlowGroups(['nope'])).toThrow('Invalid group at index 0: must be an object');
+    });
+    it('rejects a group with a missing or non-string start_id', () => {
+        expect(() => validateFlowGroups([{ end_id: 'b' }])).toThrow('Invalid group at index 0: start_id must be a non-empty string');
+        expect(() => validateFlowGroups([{ start_id: '', end_id: 'b' }])).toThrow('Invalid group at index 0: start_id must be a non-empty string');
+        expect(() => validateFlowGroups([{ start_id: 42, end_id: 'b' }])).toThrow('Invalid group at index 0: start_id must be a non-empty string');
+    });
+    it('rejects a group with a missing end_id', () => {
+        expect(() => validateFlowGroups([{ start_id: 'a' }])).toThrow('Invalid group at index 0: end_id must be a non-empty string');
+    });
+    it('accepts a valid group with no moduleIds set', () => {
+        const result = validateFlowGroups([{ summary: 'G', start_id: 'a', end_id: 'b' }]);
+        expect(result).toEqual([{ summary: 'G', start_id: 'a', end_id: 'b' }]);
+    });
+    it('rejects start_id or end_id that are not in the moduleIds set', () => {
+        const moduleIds = new Set(['a', 'b']);
+        expect(() => validateFlowGroups([{ start_id: 'missing', end_id: 'b' }], moduleIds)).toThrow('Invalid group at index 0: start_id "missing" does not match any flow module');
+        expect(() => validateFlowGroups([{ start_id: 'a', end_id: 'missing' }], moduleIds)).toThrow('Invalid group at index 0: end_id "missing" does not match any flow module');
+    });
+    it('accepts groups whose ids are all in the moduleIds set', () => {
+        const moduleIds = new Set(['a', 'b', 'c']);
+        const result = validateFlowGroups([{ start_id: 'a', end_id: 'c', summary: 'G' }], moduleIds);
+        expect(result).toEqual([{ start_id: 'a', end_id: 'c', summary: 'G' }]);
+    });
+});

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 &&