windmill-components 1.623.2 → 1.655.0

package/package/components/copilot/chat/ContextTextarea.svelte

@@ -120,8 +120,10 @@ function getCaretCoordinates(element, position) {
 }
 function getHighlightedText(text) {
     return text.replace(/@[\w/.\-\[\]]+/g, (match) => {
-        const contextElement = availableContext.find((c) => c.title === match.slice(1));
-        if (contextElement) {
+        const title = match.slice(1);
+        const inContext = availableContext.find((c) => c.title === title) ||
+            selectedContext.find((c) => c.title === title);
+        if (inContext) {
             return `<span class="bg-black dark:bg-white text-white dark:text-black z-10">${match}</span>`;
         }
         return match;
@@ -259,6 +261,10 @@ export function focus() {
 		oninput={handleInput}
 		onblur={() => {
 			setTimeout(() => {
+				// Don't close if focus moved to inside the tooltip (e.g., search input)
+				if (tooltipElement?.contains(document.activeElement)) {
+					return
+				}
 				showContextTooltip = false
 			}, 200)
 		}}
@@ -285,6 +291,13 @@ export function focus() {
 				onSelect={(element) => {
 					handleContextSelection(element)
 				}}
+				onSelectWorkspaceItem={(element) => {
+					onAddContext(element)
+					updateInstructionsWithContext(element)
+					showContextTooltip = false
+					// Refocus the textarea since focus may have been on the search input
+					setTimeout(() => textarea?.focus(), 0)
+				}}
 				showAllAvailable={true}
 				stringSearch={contextTooltipWord.slice(1)}
 				onViewChange={(newNumber) => {

package/package/components/copilot/chat/__tests__/app/variants/streamlined.js

@@ -50,7 +50,7 @@ For inline scripts, the code must have a \`main\` function as its entrypoint.
 - \`lint()\`: Lint all files. Returns errors/warnings grouped by frontend/backend.
 
 ### Discovery
-- \`list_workspace_runnables(query, type?)\`: Search workspace scripts and flows
+- \`search_workspace(query, type)\`: Search workspace scripts and flows
 - \`search_hub_scripts(query)\`: Search hub scripts
 
 ## Backend Runnable Configuration

package/package/components/copilot/chat/__tests__/flow/variants/minimal-single-tool.js

@@ -72,7 +72,8 @@ const MINIMAL_SINGLE_TOOL_SYSTEM_PROMPT = `You are a helpful assistant that crea
 
 **Code & Scripts:**
 - **Get language-specific coding instructions** → \`get_instructions_for_code_generation\` (call BEFORE writing code)
-- **Find workspace scripts** → \`search_scripts\`
+- **Find workspace scripts and flows** → \`search_workspace\`
+- **Get details of a specific script or flow** → \`get_runnable_details\`
 - **Find Windmill Hub scripts** → \`search_hub_scripts\`
 
 **Testing:**
@@ -298,7 +299,8 @@ Example: Before writing TypeScript/Bun code, call \`get_instructions_for_code_ge
 ### Creating Flows
 
 1. **Search for existing scripts first** (unless user explicitly asks to write from scratch):
-   - First: \`search_scripts\` to find workspace scripts
+   - First: \`search_workspace\` to find workspace scripts and flows
+   - Use \`get_runnable_details\` to inspect a specific script or flow (inputs, description, code)
    - Then: \`search_hub_scripts\` (only consider highly relevant results)
    - Only create raw scripts if no suitable script is found
 

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

@@ -1,8 +1,5 @@
 import { z } from 'zod';
-import { createSearchHubScriptsTool, createToolDef } from '../shared';
-import { FlowService, ScriptService } from '../../../../gen';
-import uFuzzy from '@leeoniya/ufuzzy';
-import { emptyString } from '../../../../utils';
+import { createSearchHubScriptsTool, createToolDef, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
 import { aiChatManager } from '../AIChatManager.svelte';
 // ============= Utility =============
 /** Maximum characters per file in get_files tool */
@@ -94,70 +91,6 @@ const getExecDatatableSqlToolDef = memo(() => createToolDef(getExecDatatableSqlS
 // ============= Selected Context Tool =============
 const getGetSelectedContextSchema = memo(() => z.object({}));
 const getGetSelectedContextToolDef = memo(() => createToolDef(getGetSelectedContextSchema(), 'get_selected_context', 'Get information about what is currently selected in the app editor. Returns the type of selection (frontend file or backend runnable) and the path/key of the selected item.'));
-// ============= Workspace Runnables Search =============
-const getListWorkspaceRunnablesSchema = memo(() => z.object({
-    query: z.string().describe('The search query to find workspace scripts and flows'),
-    type: z
-        .enum(['all', 'scripts', 'flows'])
-        .describe('Filter by type: "scripts" for scripts only, "flows" for flows only, "all" for both. Defaults to "all".')
-}));
-const getListWorkspaceRunnablesToolDef = memo(() => createToolDef(getListWorkspaceRunnablesSchema(), 'list_workspace_runnables', 'Search for workspace scripts and flows by query. Returns fully qualified paths that can be used in backend runnables.'));
-class WorkspaceRunnablesSearch {
-    uf;
-    workspace = undefined;
-    scripts = undefined;
-    flows = undefined;
-    constructor() {
-        this.uf = new uFuzzy();
-    }
-    async initScripts(workspace) {
-        if (this.scripts === undefined || this.workspace !== workspace) {
-            this.scripts = await ScriptService.listScripts({ workspace });
-            this.workspace = workspace;
-        }
-    }
-    async initFlows(workspace) {
-        if (this.flows === undefined || this.workspace !== workspace) {
-            this.flows = await FlowService.listFlows({ workspace });
-            this.workspace = workspace;
-        }
-    }
-    async searchScripts(query, workspace) {
-        await this.initScripts(workspace);
-        const scripts = this.scripts;
-        if (!scripts)
-            return [];
-        const results = this.uf.search(scripts.map((s) => (emptyString(s.summary) ? s.path : s.summary + ' (' + s.path + ')')), query.trim());
-        return (results[2]?.map((id) => ({
-            type: 'script',
-            path: scripts[id].path,
-            summary: scripts[id].summary
-        })) ?? []);
-    }
-    async searchFlows(query, workspace) {
-        await this.initFlows(workspace);
-        const flows = this.flows;
-        if (!flows)
-            return [];
-        const results = this.uf.search(flows.map((f) => (emptyString(f.summary) ? f.path : f.summary + ' (' + f.path + ')')), query.trim());
-        return (results[2]?.map((id) => ({
-            type: 'flow',
-            path: flows[id].path,
-            summary: flows[id].summary
-        })) ?? []);
-    }
-    async search(query, workspace, type = 'all') {
-        const results = [];
-        if (type === 'all' || type === 'scripts') {
-            results.push(...(await this.searchScripts(query, workspace)));
-        }
-        if (type === 'all' || type === 'flows') {
-            results.push(...(await this.searchFlows(query, workspace)));
-        }
-        return results;
-    }
-}
-const workspaceRunnablesSearch = new WorkspaceRunnablesSearch();
 // ============= Lint Result Formatting =============
 function formatLintMessages(messages) {
     let result = '';
@@ -369,7 +302,7 @@ export const getAppTools = memo(() => [
             });
             const lintResult = await helpers.setBackendRunnable(parsedArgs.key, runnable);
             toolCallbacks.setToolStatus(toolId, {
-                content: `Backend runnable '${parsedArgs.key}' analyzed`,
+                content: `Backend runnable '${parsedArgs.key}' set successfully.`,
                 result: 'Success'
             });
             return formatLintResultResponse(`Backend runnable '${parsedArgs.key}' has been set successfully.`, lintResult);
@@ -411,21 +344,8 @@ export const getAppTools = memo(() => [
         }
     },
     // Search tools
-    {
-        def: getListWorkspaceRunnablesToolDef(),
-        fn: async ({ args, workspace, toolId, toolCallbacks }) => {
-            const parsedArgs = getListWorkspaceRunnablesSchema().parse(args);
-            const type = parsedArgs.type ?? 'all';
-            toolCallbacks.setToolStatus(toolId, {
-                content: `Searching workspace ${type} for "${parsedArgs.query}"...`
-            });
-            const results = await workspaceRunnablesSearch.search(parsedArgs.query, workspace, type);
-            toolCallbacks.setToolStatus(toolId, {
-                content: `Found ${results.length} workspace runnables matching "${parsedArgs.query}"`
-            });
-            return JSON.stringify(results, null, 2);
-        }
-    },
+    createSearchWorkspaceTool(),
+    createGetRunnableDetailsTool(),
     // Hub scripts search (reuse from shared)
     createSearchHubScriptsTool(false),
     // Data table tools
@@ -562,7 +482,8 @@ For inline scripts, the code must have a \`main\` function as its entrypoint.
 - \`lint()\`: Lint all files. Returns errors/warnings grouped by frontend/backend. Use this to check for issues after making changes.
 
 ### Discovery
-- \`list_workspace_runnables(query, type?)\`: Search workspace scripts and flows
+- \`search_workspace(query, type)\`: Search workspace scripts and flows
+- \`get_runnable_details(path, type)\`: Get details (summary, description, schema, content) of a specific script or flow
 - \`search_hub_scripts(query)\`: Search hub scripts
 
 ### Data Tables
@@ -709,7 +630,7 @@ When you are using the windmill-client, do not forget that as id for variables o
 3. Make changes using \`set_frontend_file\` and \`set_backend_runnable\`. These return lint diagnostics.
 4. Use \`lint()\` at the end to check for and fix any remaining errors
 
-When creating a new app, use \`list_workspace_runnables\` or \`search_hub_scripts\` to find existing scripts/flows to reuse.
+When creating a new app, use \`search_workspace\` or \`search_hub_scripts\` to find existing scripts/flows to reuse.
 
 `;
     // Add datatable creation policy context

package/package/components/copilot/chat/context.js

@@ -1,4 +1,5 @@
 import { Code, Database, TriangleAlert, Diff, FileCode, Code2, TextSelect, Table2 } from 'lucide-svelte';
+import BarsStaggered from '../../icons/BarsStaggered.svelte';
 import {} from '../../../stores';
 import {} from 'diff';
 export const ContextIconMap = {
@@ -10,6 +11,8 @@ export const ContextIconMap = {
     app_frontend_file: FileCode,
     app_backend_runnable: Code2,
     app_code_selection: TextSelect,
-    app_datatable: Table2
+    app_datatable: Table2,
+    workspace_script: Code2,
+    workspace_flow: BarsStaggered
     // flow_module type is handled with FlowModuleIcon
 };

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

@@ -1,6 +1,5 @@
 <script lang="ts">import { Button } from '../../../common';
 import Modal from '../../../common/modal/Modal.svelte';
-import { AlertTriangleIcon } from 'lucide-svelte';
 let { open = $bindable(false), onConfirm } = $props();
 function handleConfirm() {
     open = false;
@@ -9,20 +8,18 @@ function handleConfirm() {
 </script>
 
 <Modal bind:open title="AI Changes Will Be Lost">
-	<div slot="title" class="flex items-center gap-2">
-		<AlertTriangleIcon size={20} class="text-orange-500" />
-		AI Changes Will Be Lost
-	</div>
 	<div class="py-4">
 		<p class="text-gray-700 dark:text-gray-300">
 			You have pending AI changes that will be rejected when saving. Do you want to continue?
 		</p>
 	</div>
-	<div slot="actions">
-		<div class="flex gap-2 justify-end">
-			<Button variant="contained" color="red" on:click={handleConfirm}>
-				Reject changes and save
-			</Button>
+	{#snippet actions()}
+		<div>
+			<div class="flex gap-2 justify-end">
+				<Button variant="contained" color="red" on:click={handleConfirm}>
+					Reject changes and save
+				</Button>
+			</div>
 		</div>
-	</div>
+	{/snippet}
 </Modal>

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

@@ -1,19 +1,186 @@
 import { ScriptService, JobService } from '../../../../gen';
 import { z } from 'zod';
-import uFuzzy from '@leeoniya/ufuzzy';
-import { emptyString } from '../../../../utils';
 import { createDbSchemaTool, getFormattedResourceTypes, getLangContext, SUPPORTED_CHAT_SCRIPT_LANGUAGES } from '../script/core';
-import { createSearchHubScriptsTool, createToolDef, executeTestRun, buildSchemaForTool, buildTestRunArgs, buildContextString, applyCodePiecesToFlowModules, findModuleById, SPECIAL_MODULE_IDS, formatScriptLintResult } from '../shared';
+import { createSearchHubScriptsTool, createToolDef, executeTestRun, buildSchemaForTool, buildTestRunArgs, buildContextString, applyCodePiecesToFlowModules, findModuleById, SPECIAL_MODULE_IDS, formatScriptLintResult, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
 import { inlineScriptStore, extractAndReplaceInlineScripts } from './inlineScriptsUtils';
 import { flowModulesSchema } from './openFlowZod';
 import { collectAllModuleIdsFromArray } from './utils';
 import { getFlowPrompt } from '../../../../system_prompts';
-const searchScriptsSchema = z.object({
-    query: z
-        .string()
-        .describe('The query to search for, e.g. send email, list stripe invoices, etc..')
-});
-const searchScriptsToolDef = createToolDef(searchScriptsSchema, 'search_scripts', 'Search for scripts in the workspace. Returns array of {path, summary} objects.');
+/**
+ * Navigate to a schema at a given path, handling arrays, objects, unions, and wrappers.
+ * Uses Zod 4 internal structure.
+ * @param schema The Zod schema to navigate
+ * @param path The path to navigate
+ * @param data Optional actual data to help resolve discriminated unions
+ */
+function getSchemaAtPath(schema, path, data) {
+    let current = schema;
+    let currentData = data;
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        if (!current || !current._def)
+            return null;
+        let type = current._def.type;
+        // Unwrap optional/nullable/default/catch
+        while (['optional', 'nullable', 'default', 'catch'].includes(type)) {
+            current = current._def.innerType;
+            if (!current || !current._def)
+                return null;
+            type = current._def.type;
+        }
+        // Handle arrays
+        if (type === 'array') {
+            if (typeof segment === 'number') {
+                current = current._def.element;
+                if (currentData && Array.isArray(currentData)) {
+                    currentData = currentData[segment];
+                }
+                continue;
+            }
+            // If segment is not a number, continue into element type
+            current = current._def.element;
+            i--;
+            continue;
+        }
+        // Handle objects
+        if (type === 'object') {
+            const shape = current._def.shape;
+            const key = String(segment);
+            if (shape && key in shape) {
+                current = shape[key];
+                if (currentData && typeof currentData === 'object') {
+                    currentData = currentData[key];
+                }
+                continue;
+            }
+            return null;
+        }
+        // Handle discriminated unions (shows as 'union' in Zod 4)
+        if (type === 'union') {
+            const options = current._def.options;
+            if (options) {
+                // If we have data, try to find the correct union option based on discriminator
+                if (currentData && typeof currentData === 'object') {
+                    // Check for common discriminator fields
+                    const typeValue = currentData.type;
+                    if (typeValue) {
+                        // Find option that matches this type
+                        for (const option of options) {
+                            const optionShape = option._def?.shape;
+                            const optionType = optionShape?.type?._def?.values?.[0];
+                            if (optionType === typeValue) {
+                                const remainingPath = path.slice(i);
+                                const result = getSchemaAtPath(option, remainingPath, currentData);
+                                if (result)
+                                    return result;
+                            }
+                        }
+                    }
+                }
+                // Fallback: try to find a matching schema in any of the options
+                for (const option of options) {
+                    const remainingPath = path.slice(i);
+                    const result = getSchemaAtPath(option, remainingPath, currentData);
+                    if (result)
+                        return result;
+                }
+            }
+            return null;
+        }
+        // Handle record - any string key accesses the value type
+        if (type === 'record') {
+            current = current._def.valueType;
+            if (!current)
+                return null;
+            if (currentData && typeof currentData === 'object') {
+                currentData = currentData[segment];
+            }
+            continue;
+        }
+        return null;
+    }
+    return current;
+}
+/**
+ * Format a JSON Schema object into a concise human-readable string for error messages.
+ * Prioritizes structural information (object shapes, enums) over descriptions.
+ */
+function formatJsonSchemaForError(jsonSchema) {
+    // For objects, show structure (more actionable than description)
+    if (jsonSchema.type === 'object' && jsonSchema.properties) {
+        const props = Object.entries(jsonSchema.properties)
+            .slice(0, 5) // Limit to 5 properties
+            .map(([k, v]) => {
+            // Include enum values for string properties if available
+            if (v.enum) {
+                return `${k}: ${v.enum.map((e) => JSON.stringify(e)).join('|')}`;
+            }
+            return `${k}: ${v.type || 'any'}`;
+        })
+            .join(', ');
+        const moreProps = Object.keys(jsonSchema.properties).length > 5
+            ? `, ... (${Object.keys(jsonSchema.properties).length - 5} more)`
+            : '';
+        const required = jsonSchema.required?.length
+            ? ` (required: ${jsonSchema.required.join(', ')})`
+            : '';
+        return `{ ${props}${moreProps} }${required}`;
+    }
+    if (jsonSchema.const !== undefined) {
+        return JSON.stringify(jsonSchema.const);
+    }
+    if (jsonSchema.enum) {
+        return `one of: ${jsonSchema.enum.map((v) => JSON.stringify(v)).join(', ')}`;
+    }
+    if (jsonSchema.oneOf) {
+        return jsonSchema.oneOf.map((s) => formatJsonSchemaForError(s)).join(' | ');
+    }
+    if (jsonSchema.anyOf) {
+        return jsonSchema.anyOf.map((s) => formatJsonSchemaForError(s)).join(' | ');
+    }
+    // Fall back to description for non-structural types
+    if (jsonSchema.description) {
+        return jsonSchema.description;
+    }
+    return jsonSchema.type || JSON.stringify(jsonSchema);
+}
+/**
+ * Extract a human-readable description of what a schema expects.
+ * For objects, prefers showing the actual structure over descriptions.
+ * For simpler types, uses description if available.
+ */
+function getExpectedFormat(schema) {
+    if (!schema || !schema._def)
+        return null;
+    let current = schema;
+    // Unwrap optional/nullable to get inner type
+    while (current._def.type === 'optional' || current._def.type === 'nullable') {
+        current = current._def.innerType;
+        if (!current || !current._def)
+            break;
+    }
+    // Try JSON Schema representation first for objects (more actionable than descriptions)
+    try {
+        const jsonSchema = z.toJSONSchema(schema);
+        // Skip if it's just a schema with no useful info
+        if (Object.keys(jsonSchema).length <= 1 ||
+            (Object.keys(jsonSchema).length === 1 && jsonSchema.$schema)) {
+            return null;
+        }
+        const formatted = formatJsonSchemaForError(jsonSchema);
+        if (formatted && formatted !== 'unknown' && !formatted.startsWith('{')) {
+            return formatted;
+        }
+        // For objects, only return if it has meaningful properties
+        if (formatted && formatted.startsWith('{') && formatted !== '{ }') {
+            return formatted;
+        }
+    }
+    catch {
+        // Ignore errors from toJSONSchema
+    }
+    return null;
+}
 const langSchema = z.enum(SUPPORTED_CHAT_SCRIPT_LANGUAGES);
 const resourceTypeToolSchema = z.object({
     query: z.string().describe('The query to search for, e.g. stripe, google, etc..'),
@@ -30,35 +197,6 @@ const setFlowJsonToolSchema = z.object({
     schema: z.string().optional().nullable().describe('JSON string containing the flow input schema')
 });
 const setFlowJsonToolDef = createToolDef(setFlowJsonToolSchema, 'set_flow_json', 'Set the entire flow by providing the complete flow object. This replaces all existing modules and schema.', { strict: false });
-class WorkspaceScriptsSearch {
-    uf;
-    workspace = undefined;
-    scripts = undefined;
-    constructor() {
-        this.uf = new uFuzzy();
-    }
-    async init(workspace) {
-        this.scripts = await ScriptService.listScripts({
-            workspace
-        });
-        this.workspace = workspace;
-    }
-    async search(query, workspace) {
-        if (this.scripts === undefined || this.workspace !== workspace) {
-            await this.init(workspace);
-        }
-        const scripts = this.scripts;
-        if (!scripts) {
-            throw new Error('Failed to load scripts');
-        }
-        const results = this.uf.search(scripts.map((s) => (emptyString(s.summary) ? s.path : s.summary + ' (' + s.path + ')')), query.trim());
-        const scriptResults = results[2]?.map((id) => ({
-            path: scripts[id].path,
-            summary: scripts[id].summary
-        })) ?? [];
-        return scriptResults;
-    }
-}
 // Will be overridden by setSchema
 const testRunFlowSchema = z.object({
     args: z
@@ -90,28 +228,11 @@ const getLintErrorsSchema = z.object({
     module_id: z.string().describe('The ID of the module to get lint errors for.')
 });
 const getLintErrorsToolDef = createToolDef(getLintErrorsSchema, 'get_lint_errors', 'Get lint errors and warnings from a rawscript module. Pass module_id to focus a specific module and check its errors. ALWAYS call this for EACH module where you modified inline script code.');
-const workspaceScriptsSearch = new WorkspaceScriptsSearch();
 export const flowTools = [
     createSearchHubScriptsTool(false),
     createDbSchemaTool(),
-    {
-        def: searchScriptsToolDef,
-        fn: async ({ args, workspace, toolId, toolCallbacks }) => {
-            toolCallbacks.setToolStatus(toolId, {
-                content: 'Searching for workspace scripts related to "' + args.query + '"...'
-            });
-            const parsedArgs = searchScriptsSchema.parse(args);
-            const scriptResults = await workspaceScriptsSearch.search(parsedArgs.query, workspace);
-            toolCallbacks.setToolStatus(toolId, {
-                content: 'Found ' +
-                    scriptResults.length +
-                    ' scripts in the workspace related to "' +
-                    args.query +
-                    '"'
-            });
-            return JSON.stringify(scriptResults);
-        }
-    },
+    createSearchWorkspaceTool(),
+    createGetRunnableDetailsTool(),
     {
         def: resourceTypeToolDef,
         fn: async ({ args, toolId, workspace, toolCallbacks }) => {
@@ -355,7 +476,7 @@ export const flowTools = [
             if (parsedModules) {
                 const result = flowModulesSchema.safeParse(parsedModules);
                 if (!result.success) {
-                    const errors = result.error.errors.slice(0, 5).map((e) => {
+                    const errors = result.error.issues.slice(0, 5).map((e) => {
                         const path = e.path;
                         // Try to find module id for better context
                         const moduleIndex = typeof path[0] === 'number' ? path[0] : undefined;
@@ -363,7 +484,16 @@ export const flowTools = [
                         const fieldPath = path.slice(1).join('.');
                         let message = e.message;
                         if (e.code === 'invalid_type') {
-                            message = `expected ${e.expected}, got ${e.received}`;
+                            // Zod 4 message already contains "expected X, received Y"
+                            // Try to extract expected format from schema, passing actual data
+                            // to help resolve discriminated unions correctly
+                            const targetSchema = getSchemaAtPath(flowModulesSchema, path, parsedModules);
+                            if (targetSchema) {
+                                const expectedFormat = getExpectedFormat(targetSchema);
+                                if (expectedFormat) {
+                                    message += `\n    Expected format: ${expectedFormat}`;
+                                }
+                            }
                         }
                         if (moduleId) {
                             return `Module "${moduleId}" -> ${fieldPath}: ${message}`;
@@ -434,7 +564,8 @@ export function prepareFlowSystemMessage(customPrompt) {
 - **View existing inline script code** → \`inspect_inline_script\`
 - **Change module code only** → \`set_module_code\`
 - **Get language-specific coding instructions** → \`get_instructions_for_code_generation\` (call BEFORE writing code)
-- **Find workspace scripts** → \`search_scripts\`
+- **Find workspace scripts and flows** → \`search_workspace\`
+- **Get details of a specific script or flow** → \`get_runnable_details\`
 - **Find Windmill Hub scripts** → \`search_hub_scripts\`
 
 **Testing & Linting:**
@@ -641,7 +772,8 @@ Example: Before writing TypeScript/Bun code, call \`get_instructions_for_code_ge
 ### Creating Flows
 
 1. **Search for existing scripts first** (unless user explicitly asks to write from scratch):
-   - First: \`search_scripts\` to find workspace scripts
+   - First: \`search_workspace\` to find workspace scripts and flows
+   - Use \`get_runnable_details\` to inspect a specific script or flow (inputs, description, code)
    - Then: \`search_hub_scripts\` (only consider highly relevant results)
    - Only create raw scripts if no suitable script is found