windmill-cli 1.623.1 → 1.625.0

package/esm/gen/core/OpenAPI.js

@@ -32,7 +32,7 @@ export const OpenAPI = {
     PASSWORD: undefined,
     TOKEN: getEnv("WM_TOKEN"),
     USERNAME: undefined,
-    VERSION: '1.623.1',
+    VERSION: '1.625.0',
     WITH_CREDENTIALS: true,
     interceptors: {
         request: new Interceptors(),

package/esm/gen/services.gen.js

@@ -2777,6 +2777,7 @@ export const listContextualVariables = (data) => {
  * get secondary storage names
  * @param data The data for the request.
  * @param data.workspace
+ * @param data.includeDefault If true, include "_default_" in the list if primary workspace storage is set
  * @returns string status
  * @throws ApiError
  */
@@ -2786,6 +2787,9 @@ export const getSecondaryStorageNames = (data) => {
         url: '/w/{workspace}/workspaces/get_secondary_storage_names',
         path: {
             workspace: data.workspace
+        },
+        query: {
+            include_default: data.includeDefault
         }
     });
 };
@@ -2866,6 +2870,25 @@ export const workspaceMuteCriticalAlertsUi = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * Set public app rate limit for this workspace
+ * @param data The data for the request.
+ * @param data.workspace
+ * @param data.requestBody Public app rate limit configuration
+ * @returns string Successfully updated public app rate limit settings.
+ * @throws ApiError
+ */
+export const setPublicAppRateLimit = (data) => {
+    return __request(OpenAPI, {
+        method: 'POST',
+        url: '/w/{workspace}/workspaces/public_app_rate_limit',
+        path: {
+            workspace: data.workspace
+        },
+        body: data.requestBody,
+        mediaType: 'application/json'
+    });
+};
 /**
  * login with oauth authorization flow
  * @param data The data for the request.
@@ -3700,6 +3723,22 @@ export const getHubAppById = (data) => {
         }
     });
 };
+/**
+ * get hub raw app by id
+ * @param data The data for the request.
+ * @param data.id
+ * @returns unknown raw app
+ * @throws ApiError
+ */
+export const getHubRawAppById = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/apps/hub/get_raw/{id}',
+        path: {
+            id: data.id
+        }
+    });
+};
 /**
  * get public app by custom path
  * @param data The data for the request.
@@ -12395,10 +12434,16 @@ export const clearIndex = (data) => {
     });
 };
 /**
- * List all assets in the workspace
+ * List all assets in the workspace with cursor pagination
  * @param data The data for the request.
  * @param data.workspace
- * @returns unknown all assets in the workspace
+ * @param data.perPage Number of items per page (max 1000, default 50)
+ * @param data.cursorCreatedAt Cursor timestamp for pagination (created_at of last item from previous page)
+ * @param data.cursorId Cursor ID for pagination (id of last item from previous page)
+ * @param data.assetPath Filter by asset path (case-insensitive partial match)
+ * @param data.usagePath Filter by usage path (case-insensitive partial match)
+ * @param data.assetKinds Filter by asset kinds (multiple values allowed)
+ * @returns unknown paginated assets in the workspace
  * @throws ApiError
  */
 export const listAssets = (data) => {
@@ -12407,6 +12452,14 @@ export const listAssets = (data) => {
         url: '/w/{workspace}/assets/list',
         path: {
             workspace: data.workspace
+        },
+        query: {
+            per_page: data.perPage,
+            cursor_created_at: data.cursorCreatedAt,
+            cursor_id: data.cursorId,
+            asset_path: data.assetPath,
+            usage_path: data.usagePath,
+            asset_kinds: data.assetKinds
         }
     });
 };
@@ -12429,6 +12482,22 @@ export const listAssetsByUsage = (data) => {
         mediaType: 'application/json'
     });
 };
+/**
+ * List all favorite assets for the authenticated user
+ * @param data The data for the request.
+ * @param data.workspace
+ * @returns unknown list of favorite assets
+ * @throws ApiError
+ */
+export const listFavoriteAssets = (data) => {
+    return __request(OpenAPI, {
+        method: 'GET',
+        url: '/w/{workspace}/assets/list_favorites',
+        path: {
+            workspace: data.workspace
+        }
+    });
+};
 /**
  * list available MCP tools
  * @param data The data for the request.

package/esm/src/commands/app/dev.js

@@ -190,6 +190,7 @@ const createHTML = (jsPath, cssPath) => `
     // SQL Migration Modal handling
     let pendingSqlMigration = null;
     let sqlWebSocket = null;
+    let closeModalTimeout = null;
 
     function initSqlWebSocket() {
       const wsProtocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -211,12 +212,19 @@ const createHTML = (jsPath, cssPath) => `
     }
 
     function showSqlModal(data) {
+      // Cancel any pending close from a previous migration's success
+      if (closeModalTimeout) {
+        clearTimeout(closeModalTimeout);
+        closeModalTimeout = null;
+      }
       pendingSqlMigration = data;
       document.getElementById('sql-file-name').textContent = data.fileName;
       document.getElementById('sql-datatable').textContent = data.datatable || 'Not configured';
       document.getElementById('sql-content').textContent = data.sql;
       document.getElementById('sql-result').innerHTML = '';
+      document.getElementById('sql-result').className = 'sql-result';
       document.getElementById('apply-sql-btn').disabled = !data.datatable;
+      document.getElementById('apply-sql-btn').textContent = 'Apply SQL';
       document.getElementById('sql-modal-overlay').classList.add('visible');
     }
 
@@ -257,7 +265,11 @@ const createHTML = (jsPath, cssPath) => `
         resultDiv.className = 'sql-result success';
         resultDiv.innerHTML = '<strong>Success!</strong> SQL applied and file deleted.';
         // Auto-close after success (don't send skip since server already handled it)
-        setTimeout(() => closeSqlModal(false), 1500);
+        // Save timeout ID so it can be cancelled if a new migration arrives
+        closeModalTimeout = setTimeout(() => {
+          closeModalTimeout = null;
+          closeSqlModal(false);
+        }, 1500);
       }
     }
 

package/esm/src/commands/sync/sync.js

@@ -1044,7 +1044,7 @@ export async function* readDirRecursiveWithIgnore(ignore, root) {
         }
     }
 }
-export async function elementsToMap(els, ignore, json, skips, specificItems, branchOverride) {
+export async function elementsToMap(els, ignore, json, skips, specificItems, branchOverride, isRemote) {
     const map = {};
     const processedBasePaths = new Set();
     // Cache git branch at the start to avoid repeated execSync calls per file
@@ -1209,7 +1209,8 @@ export async function elementsToMap(els, ignore, json, skips, specificItems, bra
                 continue;
             }
             // Skip base file if it's configured as branch-specific (expect branch version)
-            if (isSpecificItem(path, specificItems)) {
+            // Only for LOCAL files - remote workspace only has base paths
+            if (!isRemote && isSpecificItem(path, specificItems)) {
                 continue;
             }
             map[path] = content;
@@ -1218,13 +1219,13 @@ export async function elementsToMap(els, ignore, json, skips, specificItems, bra
     }
     return map;
 }
-async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetadataDeletion, codebases, ignoreCodebaseChanges, specificItems, branchOverride) {
+async function compareDynFSElement(els1, els2, ignore, json, skips, ignoreMetadataDeletion, codebases, ignoreCodebaseChanges, specificItems, branchOverride, isEls1Remote) {
     const [m1, m2] = els2
         ? await Promise.all([
-            elementsToMap(els1, ignore, json, skips, specificItems, branchOverride),
-            elementsToMap(els2, ignore, json, skips, specificItems, branchOverride),
+            elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote),
+            elementsToMap(els2, ignore, json, skips, specificItems, branchOverride, !isEls1Remote),
         ])
-        : [await elementsToMap(els1, ignore, json, skips, specificItems, branchOverride), {}];
+        : [await elementsToMap(els1, ignore, json, skips, specificItems, branchOverride, isEls1Remote), {}];
     const changes = [];
     function parseYaml(k, v) {
         if (k.endsWith(".script.yaml")) {
@@ -1633,7 +1634,7 @@ export async function pull(opts) {
     const local = !opts.stateful
         ? await FSFSElement(dntShim.Deno.cwd(), codebases, true)
         : await FSFSElement(path.join(dntShim.Deno.cwd(), ".wmill"), [], true);
-    const changes = await compareDynFSElement(remote, local, await ignoreF(opts), opts.json ?? false, opts, false, codebases, true, specificItems, opts.branch);
+    const changes = await compareDynFSElement(remote, local, await ignoreF(opts), opts.json ?? false, opts, false, codebases, true, specificItems, opts.branch, true);
     log.info(`remote (${workspace.name}) -> local: ${changes.length} changes to apply`);
     // Handle JSON output for dry-run
     if (opts.dryRun && opts.jsonOutput) {
@@ -1943,7 +1944,7 @@ export async function push(opts) {
     }
     const remote = ZipFSElement((await downloadZip(workspace, opts.plainSecrets, opts.skipVariables, opts.skipResources, opts.skipResourceTypes, opts.skipSecrets, opts.includeSchedules, opts.includeTriggers, opts.includeUsers, opts.includeGroups, opts.includeSettings, opts.includeKey, opts.skipWorkspaceDependencies, opts.defaultTs)), !opts.json, opts.defaultTs ?? "bun", resourceTypeToFormatExtension, false);
     const local = await FSFSElement(path.join(dntShim.Deno.cwd(), ""), codebases, false);
-    const changes = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems, opts.branch);
+    const changes = await compareDynFSElement(local, remote, await ignoreF(opts), opts.json ?? false, opts, true, codebases, false, specificItems, opts.branch, false);
     const rawWorkspaceDependencies = await getRawWorkspaceDependencies();
     const tracker = await buildTracker(changes);
     const staleScripts = [];

package/esm/src/main.js

@@ -46,7 +46,7 @@ export { flow, app, script, workspace, resource, resourceType, user, variable, h
 //     console.error(JSON.stringify(event.error, null, 4));
 //   }
 // });
-export const VERSION = "1.623.1";
+export const VERSION = "1.625.0";
 // Re-exported from constants.ts to maintain backwards compatibility
 export { WM_FORK_PREFIX } from "./core/constants.js";
 const command = new Command()

package/esm/src/utils/metadata.js

@@ -137,19 +137,87 @@ export async function updateScriptSchema(scriptContent, language, metadataConten
         delete metadataContent.no_main_func;
     }
 }
-async function updateScriptLock(workspace, scriptContent, language, remotePath, metadataContent, rawWorkspaceDependencies) {
-    if (!(workspaceDependenciesLanguages.some((l) => l.language == language) ||
-        language == "deno" ||
-        language == "rust" ||
-        language == "ansible")) {
-        return;
+const LANG_ANNOTATION_CONFIG = {
+    python3: { comment: "#", keyword: "requirements", validityRe: /^#\s?(\S+)\s*$/ },
+    bun: { comment: "//", keyword: "package_json" },
+    nativets: { comment: "//", keyword: "package_json" },
+    go: { comment: "//", keyword: "go_mod" },
+    php: { comment: "//", keyword: "composer_json" },
+};
+export function extractWorkspaceDepsAnnotation(scriptContent, language) {
+    const config = LANG_ANNOTATION_CONFIG[language];
+    if (!config)
+        return null;
+    const { comment, keyword, validityRe } = config;
+    const extraMarker = `extra_${keyword}:`;
+    const manualMarker = `${keyword}:`;
+    const lines = scriptContent.split("\n");
+    // Find first annotation line (mirrors Rust find_position)
+    let pos = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const l = lines[i];
+        if (l.startsWith(comment) && (l.includes(extraMarker) || l.includes(manualMarker))) {
+            pos = i;
+            break;
+        }
     }
-    if (Object.keys(rawWorkspaceDependencies).length > 0) {
-        const dependencyPaths = Object.keys(rawWorkspaceDependencies).join(', ');
-        log.info(`Generating script lock for ${remotePath} with raw workspace dependencies: ${dependencyPaths}`);
+    if (pos === -1)
+        return null;
+    const annotationLine = lines[pos];
+    const mode = annotationLine.includes(extraMarker) ? "extra" : "manual";
+    // Parse external references from the annotation line
+    const marker = mode === "extra" ? extraMarker : manualMarker;
+    const unparsed = annotationLine.replaceAll(marker, "").replaceAll(comment, "");
+    const external = unparsed
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    // Parse inline deps from subsequent lines
+    const inlineParts = [];
+    for (let i = pos + 1; i < lines.length; i++) {
+        const l = lines[i];
+        if (validityRe) {
+            const match = validityRe.exec(l);
+            if (match && match[1]) {
+                inlineParts.push(match[1]);
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            if (!l.startsWith(comment)) {
+                break;
+            }
+            inlineParts.push(l.substring(comment.length));
+        }
+    }
+    const inlineStr = inlineParts.join("\n");
+    const inline = inlineStr.trim().length > 0 ? inlineStr : null;
+    return { mode, external, inline };
+}
+export async function computeLockCacheKey(scriptContent, language, rawWorkspaceDependencies) {
+    const annotation = extractWorkspaceDepsAnnotation(scriptContent, language);
+    const annotationStr = annotation
+        ? `${annotation.mode}|${annotation.external.join(",")}|${annotation.inline ?? ""}`
+        : "none";
+    const sortedDepsKeys = Object.keys(rawWorkspaceDependencies).sort();
+    const depsStr = sortedDepsKeys.map((k) => `${k}=${rawWorkspaceDependencies[k]}`).join(";");
+    return await generateHash(`${language}|${annotationStr}|${depsStr}`);
+}
+const lockCache = new Map();
+export function clearLockCache() {
+    lockCache.clear();
+}
+async function fetchScriptLock(workspace, scriptContent, language, remotePath, rawWorkspaceDependencies) {
+    const hasRawDeps = Object.keys(rawWorkspaceDependencies).length > 0;
+    const cacheKey = hasRawDeps
+        ? await computeLockCacheKey(scriptContent, language, rawWorkspaceDependencies)
+        : undefined;
+    if (cacheKey && lockCache.has(cacheKey)) {
+        log.info(`Using cached lockfile for ${remotePath}`);
+        return lockCache.get(cacheKey);
     }
-    // generate the script lock running a dependency job in Windmill and update it inplace
-    // TODO: update this once the client is released
     const extraHeaders = getHeaders();
     const rawResponse = await fetch(`${workspace.remote}api/w/${workspace.workspaceId}/jobs/run/dependencies`, {
         method: "POST",
@@ -182,22 +250,10 @@ async function updateScriptLock(workspace, scriptContent, language, remotePath,
             }
             throw new LockfileGenerationError(`Failed to generate lockfile: ${JSON.stringify(response, null, 2)}`);
         }
-        const lockPath = remotePath + ".script.lock";
-        if (lock != "") {
-            await dntShim.Deno.writeTextFile(lockPath, lock);
-            metadataContent.lock = "!inline " + lockPath.replaceAll(SEP, "/");
-        }
-        else {
-            try {
-                if (await dntShim.Deno.stat(lockPath)) {
-                    await dntShim.Deno.remove(lockPath);
-                }
-            }
-            catch (e) {
-                log.info(colors.yellow(`Error removing lock file ${lockPath}: ${e}`));
-            }
-            metadataContent.lock = "";
+        if (cacheKey) {
+            lockCache.set(cacheKey, lock);
         }
+        return lock;
     }
     catch (e) {
         if (e instanceof LockfileGenerationError) {
@@ -206,6 +262,35 @@ async function updateScriptLock(workspace, scriptContent, language, remotePath,
         throw new LockfileGenerationError(`Failed to generate lockfile:${rawResponse.statusText}, ${responseText}, ${e}`);
     }
 }
+async function updateScriptLock(workspace, scriptContent, language, remotePath, metadataContent, rawWorkspaceDependencies) {
+    if (!(workspaceDependenciesLanguages.some((l) => l.language == language) ||
+        language == "deno" ||
+        language == "rust" ||
+        language == "ansible")) {
+        return;
+    }
+    if (Object.keys(rawWorkspaceDependencies).length > 0) {
+        const dependencyPaths = Object.keys(rawWorkspaceDependencies).join(', ');
+        log.info(`Generating script lock for ${remotePath} with raw workspace dependencies: ${dependencyPaths}`);
+    }
+    const lock = await fetchScriptLock(workspace, scriptContent, language, remotePath, rawWorkspaceDependencies);
+    const lockPath = remotePath + ".script.lock";
+    if (lock != "") {
+        await dntShim.Deno.writeTextFile(lockPath, lock);
+        metadataContent.lock = "!inline " + lockPath.replaceAll(SEP, "/");
+    }
+    else {
+        try {
+            if (await dntShim.Deno.stat(lockPath)) {
+                await dntShim.Deno.remove(lockPath);
+            }
+        }
+        catch (e) {
+            log.info(colors.yellow(`Error removing lock file ${lockPath}: ${e}`));
+        }
+        metadataContent.lock = "";
+    }
+}
 ////////////////////////////////////////////////////////////////////////////////////////////
 // below functions copied from Windmill's FE inferArgs function. TODO: refactor           //
 ////////////////////////////////////////////////////////////////////////////////////////////

package/esm/windmill-utils-internal/src/inline-scripts/extractor.js

@@ -1,4 +1,18 @@
 import { newPathAssigner } from "../path-utils/path-assigner.js";
+function extractRawscriptInline(id, summary, rawscript, mapping, separator, assigner) {
+    const [basePath, ext] = assigner.assignPath(summary ?? id, rawscript.language);
+    const path = mapping[id] ?? basePath + ext;
+    const content = rawscript.content;
+    const r = [{ path: path, content: content }];
+    rawscript.content = "!inline " + path.replaceAll(separator, "/");
+    const lock = rawscript.lock;
+    if (lock && lock != "") {
+        const lockPath = basePath + "lock";
+        rawscript.lock = "!inline " + lockPath.replaceAll(separator, "/");
+        r.push({ path: lockPath, content: lock });
+    }
+    return r;
+}
 /**
  * Extracts inline scripts from flow modules, converting them to separate files
  * and replacing the original content with file references.
@@ -16,18 +30,7 @@ export function extractInlineScripts(modules, mapping = {}, separator = "/", def
     const assigner = pathAssigner ?? newPathAssigner(defaultTs ?? "bun", { skipInlineScriptSuffix: options?.skipInlineScriptSuffix });
     return modules.flatMap((m) => {
         if (m.value.type == "rawscript") {
-            const [basePath, ext] = assigner.assignPath(m.summary, m.value.language);
-            const path = mapping[m.id] ?? basePath + ext;
-            const content = m.value.content;
-            const r = [{ path: path, content: content }];
-            m.value.content = "!inline " + path.replaceAll(separator, "/");
-            const lock = m.value.lock;
-            if (lock && lock != "") {
-                const lockPath = basePath + "lock";
-                m.value.lock = "!inline " + lockPath.replaceAll(separator, "/");
-                r.push({ path: lockPath, content: lock });
-            }
-            return r;
+            return extractRawscriptInline(m.id, m.summary, m.value, mapping, separator, assigner);
         }
         else if (m.value.type == "forloopflow") {
             return extractInlineScripts(m.value.modules, mapping, separator, defaultTs, assigner);
@@ -44,6 +47,16 @@ export function extractInlineScripts(modules, mapping = {}, separator = "/", def
                 ...extractInlineScripts(m.value.default, mapping, separator, defaultTs, assigner),
             ];
         }
+        else if (m.value.type == "aiagent") {
+            return (m.value.tools ?? []).flatMap((tool) => {
+                const toolValue = tool.value;
+                // Only process flowmodule tools with rawscript type
+                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript') {
+                    return [];
+                }
+                return extractRawscriptInline(tool.id, tool.summary, toolValue, mapping, separator, assigner);
+            });
+        }
         else {
             return [];
         }
@@ -81,6 +94,15 @@ export function extractCurrentMapping(modules, mapping = {}) {
             m.value.branches.forEach((b) => extractCurrentMapping(b.modules, mapping));
             extractCurrentMapping(m.value.default, mapping);
         }
+        else if (m.value.type === "aiagent") {
+            (m.value.tools ?? []).forEach((tool) => {
+                const toolValue = tool.value;
+                if (!toolValue || toolValue.tool_type !== 'flowmodule' || toolValue.type !== 'rawscript' || !toolValue.content || !toolValue.content.startsWith("!inline")) {
+                    return;
+                }
+                mapping[tool.id] = toolValue.content.trim().split(" ")[1];
+            });
+        }
     });
     return mapping;
 }

package/esm/windmill-utils-internal/src/inline-scripts/replacer.js

@@ -1,3 +1,39 @@
+async function replaceRawscriptInline(id, rawscript, fileReader, logger, separator, removeLocks) {
+    if (!rawscript.content || !rawscript.content.startsWith("!inline")) {
+        return;
+    }
+    const path = rawscript.content.split(" ")[1];
+    const pathSuffix = path.split(".").slice(1).join(".");
+    const newPath = id + "." + pathSuffix;
+    try {
+        rawscript.content = await fileReader(path);
+    }
+    catch {
+        logger.error(`Script file ${path} not found`);
+        try {
+            rawscript.content = await fileReader(newPath);
+        }
+        catch {
+            logger.error(`Script file ${newPath} not found`);
+        }
+    }
+    const lock = rawscript.lock;
+    if (removeLocks && removeLocks.includes(path)) {
+        rawscript.lock = undefined;
+    }
+    else if (lock &&
+        typeof lock === "string" &&
+        lock.trimStart().startsWith("!inline ")) {
+        const lockPath = lock.split(" ")[1];
+        try {
+            rawscript.lock = await fileReader(lockPath.replaceAll("/", separator));
+        }
+        catch {
+            logger.error(`Lock file ${lockPath} not found, treating as empty`);
+            rawscript.lock = "";
+        }
+    }
+}
 /**
  * Replaces inline script references with actual file content from the filesystem.
  * This function recursively processes all flow modules and their nested structures.
@@ -17,63 +53,8 @@ export async function replaceInlineScripts(modules, fileReader, logger = {
         if (!module.value) {
             throw new Error(`Module value is undefined for module ${module.id}`);
         }
-        if (module.value.type === "rawscript" && module.value.content && module.value.content.startsWith("!inline")) {
-            const path = module.value.content.split(" ")[1];
-            // const pathPrefix = path.split(".")[0];
-            const pathSuffix = path.split(".").slice(1).join(".");
-            // new path is the module id with the same suffix
-            const newPath = module.id + "." + pathSuffix;
-            try {
-                module.value.content = await fileReader(path);
-            }
-            catch {
-                logger.error(`Script file ${path} not found`);
-                // try new path
-                try {
-                    module.value.content = await fileReader(newPath);
-                }
-                catch {
-                    logger.error(`Script file ${newPath} not found`);
-                }
-            }
-            // rename the file if the prefix is different from the module id (fix old naming)
-            // if (pathPrefix != module.id && renamer) {
-            //   logger.info(`Renaming ${path} to ${module.id}.${pathSuffix}`);
-            //   try {
-            //     renamer(localPath + path, localPath + module.id + "." + pathSuffix);
-            //   } catch {
-            //     logger.info(`Failed to rename ${path} to ${module.id}.${pathSuffix}`);
-            //   }
-            // }
-            const lock = module.value.lock;
-            if (removeLocks && removeLocks.includes(path)) {
-                module.value.lock = undefined;
-                // delete the file if the prefix is different from the module id (fix old naming)
-                // if (lock && lock != "") {
-                //   const path = lock.split(" ")[1];
-                //   const pathPrefix = path.split(".")[0];
-                //   if (pathPrefix != module.id && deleter) {
-                //     logger.info(`Deleting ${path}`);
-                //     try {
-                //       deleter(localPath + path);
-                //     } catch {
-                //       logger.error(`Failed to delete ${path}`);
-                //     } 
-                //   }
-                // }
-            }
-            else if (lock &&
-                typeof lock == "string" &&
-                lock.trimStart().startsWith("!inline ")) {
-                const path = lock.split(" ")[1];
-                try {
-                    module.value.lock = await fileReader(path.replaceAll("/", separator));
-                }
-                catch {
-                    logger.error(`Lock file ${path} not found, treating as empty`);
-                    module.value.lock = "";
-                }
-            }
+        if (module.value.type === "rawscript") {
+            await replaceRawscriptInline(module.id, module.value, fileReader, logger, separator, removeLocks);
         }
         else if (module.value.type === "forloopflow" || module.value.type === "whileloopflow") {
             await replaceInlineScripts(module.value.modules, fileReader, logger, localPath, separator, removeLocks);
@@ -89,5 +70,16 @@ export async function replaceInlineScripts(modules, fileReader, logger = {
             }));
             await replaceInlineScripts(module.value.default, fileReader, logger, localPath, separator, removeLocks);
         }
+        else if (module.value.type === "aiagent") {
+            await Promise.all((module.value.tools ?? []).map(async (tool) => {
+                const toolValue = tool.value;
+                if (!toolValue ||
+                    toolValue.tool_type !== "flowmodule" ||
+                    toolValue.type !== "rawscript") {
+                    return;
+                }
+                await replaceRawscriptInline(tool.id, toolValue, fileReader, logger, separator, removeLocks);
+            }));
+        }
     }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windmill-cli",
-  "version": "1.623.1",
+  "version": "1.625.0",
   "description": "CLI for Windmill",
   "repository": {
     "type": "git",