windmill-components 1.700.1 → 1.700.3

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

@@ -1,208 +1,15 @@
 import { ScriptService, JobService } from '../../../../gen';
 import { z } from 'zod';
 import { createDbSchemaTool, getFormattedResourceTypes, getLangContext, SUPPORTED_CHAT_SCRIPT_LANGUAGES } from '../script/core';
-import { createSearchHubScriptsTool, createToolDef, executeTestRun, buildSchemaForTool, buildTestRunArgs, buildContextString, applyCodePiecesToFlowModules, SPECIAL_MODULE_IDS, formatScriptLintResult, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
+import { createSearchHubScriptsTool, createToolDef, findAndReplace, executeTestRun, buildSchemaForTool, buildTestRunArgs, buildContextString, applyCodePiecesToFlowModules, SPECIAL_MODULE_IDS, formatScriptLintResult, createSearchWorkspaceTool, createGetRunnableDetailsTool } from '../shared';
 import { createWorkspaceMutationTools } from '../workspaceTools';
 import { findModuleInFlow, findModuleInModules } from '../../../flows/flowTree';
 import { createInlineScriptSession } from './inlineScriptsUtils';
 import { validateFlowGroups } from './helperUtils';
-import { flowModuleSchema, flowModulesSchema } from './openFlowZod.gen';
+import { flowModuleSchema } from './openFlowZod.gen';
 import { collectAllFlowModuleIdsFromModules } from '../../../flows/flowTree';
+import { buildEditableFlowJson as buildEditableFlowJsonBase, validateEditableFlowJson, validateFlowModules, validateFlowSchema } from './editableFlowJson';
 import { FLOW_CHAT_SPECIAL_MODULES, getFlowPrompt } from '../../../../system_prompts';
-/**
- * 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;
-}
-function countExactMatches(content, search) {
-    if (search.length === 0) {
-        return 0;
-    }
-    let count = 0;
-    let index = 0;
-    while ((index = content.indexOf(search, index)) !== -1) {
-        count++;
-        index += search.length;
-    }
-    return count;
-}
-function replaceFirstExactMatch(content, search, replace) {
-    const index = content.indexOf(search);
-    if (index === -1) {
-        return content;
-    }
-    return content.slice(0, index) + replace + content.slice(index + search.length);
-}
 function formatEmptyInlineScriptWarning({ emptyInlineScriptModuleIds }) {
     if (emptyInlineScriptModuleIds.length === 0) {
         return '';
@@ -210,154 +17,18 @@ function formatEmptyInlineScriptWarning({ emptyInlineScriptModuleIds }) {
     const moduleList = emptyInlineScriptModuleIds.map((id) => `'${id}'`).join(', ');
     return ` Warning: inline scripts ${moduleList} are empty for now. Use set_module_code to fill them in.`;
 }
-function validateFlowModules(rawModules) {
-    if (!Array.isArray(rawModules)) {
-        throw new Error('Flow modules must be an array');
-    }
-    const parsedModules = rawModules;
-    const result = flowModulesSchema.safeParse(parsedModules);
-    if (!result.success) {
-        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;
-            const moduleId = moduleIndex !== undefined ? parsedModules[moduleIndex]?.id : undefined;
-            const fieldPath = path.slice(1).join('.');
-            let message = e.message;
-            if (e.code === 'invalid_type') {
-                // 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}`;
-            }
-            return `${path.join('.')}: ${message}`;
-        });
-        throw new Error(`Invalid flow modules:\n${errors.join('\n')}`);
-    }
-    const ids = collectAllFlowModuleIdsFromModules(parsedModules);
-    if (ids.length !== new Set(ids).size) {
-        throw new Error('Duplicate module IDs found in flow');
-    }
-    const reservedIds = ids.filter((id) => id === SPECIAL_MODULE_IDS.PREPROCESSOR || id === SPECIAL_MODULE_IDS.FAILURE);
-    if (reservedIds.length > 0) {
-        throw new Error('Special modules must be provided via preprocessor_module and failure_module, not inside modules');
-    }
-    return parsedModules;
-}
-function validateFlowSchema(rawSchema) {
-    if (rawSchema == null) {
-        return null;
-    }
-    if (typeof rawSchema !== 'object' || Array.isArray(rawSchema)) {
-        throw new Error('Flow schema must be an object or null');
-    }
-    return rawSchema;
-}
-function validateOptionalFlowModule(rawModule, fieldName) {
-    if (rawModule == null) {
-        return null;
-    }
-    const result = flowModuleSchema.safeParse(rawModule);
-    if (!result.success) {
-        const error = result.error.issues[0];
-        throw new Error(`Invalid ${fieldName}: ${error?.message ?? 'unknown error'}`);
-    }
-    return result.data;
-}
-function validateEditableFlowJson(rawFlow) {
-    if (!rawFlow || typeof rawFlow !== 'object' || Array.isArray(rawFlow)) {
-        throw new Error('Flow JSON must be an object');
-    }
-    const flow = rawFlow;
-    const modules = validateFlowModules(flow.modules);
-    const schema = validateFlowSchema(flow.schema);
-    const preprocessorModule = validateOptionalFlowModule(flow.preprocessor_module, 'preprocessor_module');
-    const failureModule = validateOptionalFlowModule(flow.failure_module, 'failure_module');
-    const groupModuleIds = new Set(collectAllFlowModuleIdsFromModules(modules));
-    const groups = validateFlowGroups(flow.groups, groupModuleIds);
-    if (preprocessorModule) {
-        if (preprocessorModule.id !== SPECIAL_MODULE_IDS.PREPROCESSOR) {
-            throw new Error(`Invalid preprocessor_module: id must be "${SPECIAL_MODULE_IDS.PREPROCESSOR}"`);
-        }
-        if (preprocessorModule.value.type !== 'rawscript' &&
-            preprocessorModule.value.type !== 'script') {
-            throw new Error('Invalid preprocessor_module: only "rawscript" and "script" modules are supported');
-        }
-    }
-    if (failureModule) {
-        if (failureModule.id !== SPECIAL_MODULE_IDS.FAILURE) {
-            throw new Error(`Invalid failure_module: id must be "${SPECIAL_MODULE_IDS.FAILURE}"`);
-        }
-        if (failureModule.value.type !== 'rawscript' && failureModule.value.type !== 'script') {
-            throw new Error('Invalid failure_module: only "rawscript" and "script" modules are supported');
-        }
-    }
-    const ids = new Set(collectAllFlowModuleIdsFromModules(modules));
-    if (preprocessorModule) {
-        if (ids.has(preprocessorModule.id)) {
-            throw new Error(`Duplicate module ID found in preprocessor_module: ${preprocessorModule.id}`);
-        }
-        ids.add(preprocessorModule.id);
-    }
-    if (failureModule && ids.has(failureModule.id)) {
-        throw new Error(`Duplicate module ID found in failure_module: ${failureModule.id}`);
-    }
-    return {
-        modules,
-        schema,
-        preprocessor_module: preprocessorModule,
-        failure_module: failureModule,
-        groups
-    };
-}
+/**
+ * Build the agent-facing compact view of a flow, with editor-only post-processing
+ * (insert `[#START]` / `[#END]` markers around code pieces selected as context).
+ * Delegates to the shared `buildEditableFlowJson` for the rest.
+ */
 function buildEditableFlowJson(flow, inlineScriptSession, selectedContext = []) {
+    const json = buildEditableFlowJsonBase({ value: flow.value, schema: flow.schema }, inlineScriptSession);
     const codePieces = selectedContext.filter((c) => c.type === 'flow_module_code_piece');
-    const optimizedModules = inlineScriptSession
-        ? inlineScriptSession.extractAndReplaceInlineScripts(flow.value.modules)
-        : flow.value.modules;
-    const modules = applyCodePiecesToFlowModules(codePieces, optimizedModules);
-    let preprocessorModule = flow.value.preprocessor_module;
-    if (preprocessorModule?.value?.type === 'rawscript' &&
-        preprocessorModule.value.content &&
-        inlineScriptSession) {
-        inlineScriptSession.set(preprocessorModule.id, preprocessorModule.value.content);
-        preprocessorModule = {
-            ...preprocessorModule,
-            value: {
-                ...preprocessorModule.value,
-                content: `inline_script.${preprocessorModule.id}`
-            }
-        };
+    if (codePieces.length === 0) {
+        return json;
     }
-    let failureModule = flow.value.failure_module;
-    if (failureModule?.value?.type === 'rawscript' &&
-        failureModule.value.content &&
-        inlineScriptSession) {
-        inlineScriptSession.set(failureModule.id, failureModule.value.content);
-        failureModule = {
-            ...failureModule,
-            value: {
-                ...failureModule.value,
-                content: `inline_script.${failureModule.id}`
-            }
-        };
-    }
-    return {
-        modules,
-        schema: flow.schema ?? null,
-        preprocessor_module: preprocessorModule ?? null,
-        failure_module: failureModule ?? null,
-        groups: flow.value.groups ?? null
-    };
+    return { ...json, modules: applyCodePiecesToFlowModules(codePieces, json.modules) };
 }
 const langSchema = z.enum(SUPPORTED_CHAT_SCRIPT_LANGUAGES);
 const resourceTypeToolSchema = z.object({
@@ -710,19 +381,10 @@ export const flowTools = [
             // then copy extracted inline scripts back into the helper session before applying the patch.
             const inlineScriptSession = createInlineScriptSession();
             const currentFlowJson = JSON.stringify(buildEditableFlowJson(flow, inlineScriptSession));
-            const matchCount = countExactMatches(currentFlowJson, oldString);
-            if (matchCount === 0) {
-                throw new Error('old_string was not found in the current flow JSON.');
-            }
-            if (!replaceAll && matchCount !== 1) {
-                throw new Error(`old_string matched ${matchCount} locations. Make it more specific or set replace_all to true.`);
-            }
             toolCallbacks.setToolStatus(toolId, {
                 content: 'Applying JSON patch...'
             });
-            const updatedFlowJson = replaceAll
-                ? currentFlowJson.split(oldString).join(newString)
-                : replaceFirstExactMatch(currentFlowJson, oldString, newString);
+            const updatedFlowJson = findAndReplace(currentFlowJson, oldString, newString, replaceAll, 'current flow JSON');
             let parsedFlow;
             try {
                 parsedFlow = validateEditableFlowJson(JSON.parse(updatedFlowJson));

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import type { FlowModule, FlowValue } from '../../../../gen';
+import type { InlineScriptSession } from './inlineScriptsUtils';
+import { type FlowGroup } from './helperUtils';
+/**
+ * Compact, agent-friendly representation of a flow.
+ *
+ * Inline rawscript content is replaced with `inline_script.<moduleId>` placeholders
+ * by `buildEditableFlowJson` so flows stay short in tool I/O. Use the matching
+ * InlineScriptSession to recover the actual content.
+ */
+export type EditableFlowJson = {
+    modules: FlowModule[];
+    schema: Record<string, any> | null;
+    preprocessor_module: FlowModule | null;
+    failure_module: FlowModule | null;
+    groups: FlowGroup[] | null;
+};
+/** Optional input to the rich-error path of `validateEditableFlowJson`. */
+type SchemaErrorContext = {
+    /** Custom modules schema to validate against (defaults to flowModulesSchema). */
+    modulesSchema?: z.ZodTypeAny;
+};
+export declare function validateFlowModules(rawModules: unknown, ctx?: SchemaErrorContext): FlowModule[];
+export declare function validateFlowSchema(rawSchema: unknown): Record<string, any> | null;
+/**
+ * Parse and validate a raw object as an `EditableFlowJson`. Validates module
+ * shape, schema shape, optional special modules (with their reserved ids),
+ * groups, and that no module ids collide.
+ */
+export declare function validateEditableFlowJson(rawFlow: unknown, ctx?: SchemaErrorContext): EditableFlowJson;
+/**
+ * Build the agent-facing compact view of a flow. When an `InlineScriptSession`
+ * is provided, every rawscript module's `content` is moved into the session
+ * and replaced with the placeholder `inline_script.<moduleId>` (preprocessor
+ * and failure modules included).
+ */
+export declare function buildEditableFlowJson(flow: {
+    value: FlowValue;
+    schema?: Record<string, any> | null | undefined;
+}, inlineScriptSession?: InlineScriptSession): EditableFlowJson;
+/**
+ * Inverse of `buildEditableFlowJson`. Replaces `inline_script.<moduleId>`
+ * placeholders in `editable.modules` and the special modules with the content
+ * stored in `session`. Other fields on the original FlowValue (`same_worker`,
+ * `concurrent_limit`, etc.) are preserved.
+ *
+ * Pair with `buildEditableFlowJson` for round-trip patches: extract → patch
+ * the compact view → restore.
+ */
+export declare function applyEditableFlowJsonToFlow(originalValue: FlowValue, editable: EditableFlowJson, session: InlineScriptSession): FlowValue;
+export {};