windmill-components 1.677.0 → 1.687.0

package/package/components/copilot/chat/shared.js

@@ -11,6 +11,7 @@ export const SPECIAL_MODULE_IDS = {
 };
 import { get } from 'svelte/store';
 import { workspaceStore } from '../../../stores';
+import { findModuleInModules } from '../../flows/flowTree';
 import { z } from 'zod';
 import { ScriptService, FlowService, JobService } from '../../../gen';
 import uFuzzy from '@leeoniya/ufuzzy';
@@ -45,6 +46,51 @@ function prettifyCodeArguments(content) {
     codeContent = codeContent.replace(/\\\\/g, '\\');
     return codeContent;
 }
+function decodeEscapedToolString(content) {
+    return content
+        .replace(/\\n/g, '\n')
+        .replace(/\\t/g, '\t')
+        .replace(/\\"/g, '"')
+        .replace(/\\\\/g, '\\');
+}
+function extractJsonStringProperty(content, property) {
+    const propertyKey = `"${property}"`;
+    const propertyIndex = content.indexOf(propertyKey);
+    if (propertyIndex === -1) {
+        return undefined;
+    }
+    let cursor = propertyIndex + propertyKey.length;
+    while (cursor < content.length && /\s/.test(content[cursor] ?? '')) {
+        cursor++;
+    }
+    if (content[cursor] !== ':') {
+        return undefined;
+    }
+    cursor++;
+    while (cursor < content.length && /\s/.test(content[cursor] ?? '')) {
+        cursor++;
+    }
+    if (content[cursor] !== '"') {
+        return undefined;
+    }
+    const start = cursor + 1;
+    let escaped = false;
+    for (let index = start; index < content.length; index++) {
+        const char = content[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            return content.slice(start, index);
+        }
+    }
+    return content.slice(start);
+}
 // Prettify function for set_module_code - extracts code from moduleId/code JSON
 function prettifySetModuleCode(content) {
     let codeContent = content;
@@ -56,19 +102,37 @@ function prettifySetModuleCode(content) {
             }
         }
         catch {
-            // If JSON is incomplete during streaming, try to extract code property manually
-            const codeMatch = content.match(/"code"\s*:\s*"([\s\S]*?)(?:"\s*}?\s*$|$)/);
-            if (codeMatch) {
-                codeContent = codeMatch[1];
+            const extractedCode = extractJsonStringProperty(content, 'code');
+            if (extractedCode !== undefined) {
+                codeContent = extractedCode;
             }
         }
     }
-    // Convert escape sequences
-    codeContent = codeContent.replace(/\\n/g, '\n');
-    codeContent = codeContent.replace(/\\t/g, '\t');
-    codeContent = codeContent.replace(/\\"/g, '"');
-    codeContent = codeContent.replace(/\\\\/g, '\\');
-    return codeContent;
+    return decodeEscapedToolString(codeContent);
+}
+function prettifyPatchReplacement(content) {
+    let newString;
+    if (typeof content === 'string' && content.trim().startsWith('{')) {
+        try {
+            const parsed = JSON.parse(content);
+            if (typeof parsed.new_string === 'string') {
+                newString = parsed.new_string;
+            }
+        }
+        catch {
+            newString = extractJsonStringProperty(content, 'new_string');
+        }
+    }
+    if (newString === undefined) {
+        return content;
+    }
+    return decodeEscapedToolString(newString);
+}
+function prettifyPatchFlowJson(content) {
+    return prettifyPatchReplacement(content);
+}
+function prettifyPatchFile(content) {
+    return prettifyPatchReplacement(content);
 }
 // Prettify function for module value JSON - extracts the 'value' property and formats it
 function prettifyModuleValue(content) {
@@ -128,6 +192,8 @@ function prettifyModuleValue(content) {
 export const TOOL_PRETTIFY_MAP = {
     edit_code: prettifyCodeArguments,
     set_module_code: prettifySetModuleCode,
+    patch_flow_json: prettifyPatchFlowJson,
+    patch_file: prettifyPatchFile,
     add_module: prettifyModuleValue,
     modify_module: prettifyModuleValue
 };
@@ -148,37 +214,6 @@ export const extractAllModules = (modules) => {
         return [m];
     });
 };
-export const findModuleById = (modules, moduleId) => {
-    for (const module of modules) {
-        if (module.id === moduleId) {
-            return module;
-        }
-        if (module.value.type === 'forloopflow' || module.value.type === 'whileloopflow') {
-            const found = findModuleById(module.value.modules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-        if (module.value.type === 'branchall') {
-            const allModules = module.value.branches.flatMap((b) => b.modules);
-            const found = findModuleById(allModules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-        if (module.value.type === 'branchone') {
-            const allModules = [
-                ...module.value.branches.flatMap((b) => b.modules),
-                ...module.value.default
-            ];
-            const found = findModuleById(allModules, moduleId);
-            if (found) {
-                return found;
-            }
-        }
-    }
-    return undefined;
-};
 const applyCodePieceToCodeContext = (codePieces, codeContext) => {
     let code = codeContext.split('\n');
     let shiftOffset = 0;
@@ -203,12 +238,12 @@ export function applyCodePiecesToFlowModules(codePieces, flowModules) {
     const modifiedModules = JSON.parse(JSON.stringify(flowModules));
     // Apply code pieces to each module
     for (const [moduleId, pieces] of moduleCodePieces) {
-        const module = findModuleById(modifiedModules, moduleId);
+        const module = findModuleInModules(modifiedModules, moduleId);
         if (module && module.value.type === 'rawscript' && module.value.content) {
             module.value.content = applyCodePieceToCodeContext(pieces, module.value.content);
         }
     }
-    return JSON.stringify(modifiedModules, null, 2);
+    return modifiedModules;
 }
 export function buildContextString(selectedContext) {
     const dbTemplate = `- {title}: SCHEMA: \n{schema}\n`;
@@ -398,6 +433,7 @@ export function createToolDef(zodSchema, name, description, { strict = true } =
     delete parameters.$schema;
     if (!parameters.required)
         parameters.required = [];
+    normalizeToolParameterSchema(parameters);
     return {
         type: 'function',
         function: {
@@ -446,9 +482,9 @@ export const createSearchHubScriptsTool = (withContent = false) => ({
     }
 });
 /**
- * Recursively removes format: null or format: '' from a JSON schema object
+ * Recursively normalizes JSON Schema quirks that specific providers reject.
  */
-function removeNullFormats(schema) {
+function normalizeToolParameterSchema(schema) {
     if (!schema || typeof schema !== 'object') {
         return;
     }
@@ -459,22 +495,29 @@ function removeNullFormats(schema) {
     // Recurse into properties
     if (schema.properties && typeof schema.properties === 'object') {
         for (const key of Object.keys(schema.properties)) {
-            removeNullFormats(schema.properties[key]);
+            normalizeToolParameterSchema(schema.properties[key]);
         }
     }
     // Recurse into items (for arrays)
     if (schema.items) {
-        removeNullFormats(schema.items);
+        if (Array.isArray(schema.items)) {
+            for (const item of schema.items) {
+                normalizeToolParameterSchema(item);
+            }
+        }
+        else {
+            normalizeToolParameterSchema(schema.items);
+        }
     }
     // Recurse into additionalProperties if it's an object schema
     if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
-        removeNullFormats(schema.additionalProperties);
+        normalizeToolParameterSchema(schema.additionalProperties);
     }
     // Recurse into allOf, anyOf, oneOf
     for (const key of ['allOf', 'anyOf', 'oneOf']) {
         if (Array.isArray(schema[key])) {
             for (const subSchema of schema[key]) {
-                removeNullFormats(subSchema);
+                normalizeToolParameterSchema(subSchema);
             }
         }
     }
@@ -489,8 +532,8 @@ export async function buildSchemaForTool(toolDef, schemaBuilder) {
             throw new Error(`Invalid flow inputs schema: ${invalidProperties.join(', ')}`);
         }
         toolDef.function.parameters = { ...schema, additionalProperties: false };
-        // recursively remove any format: null or format: '' (empty string) from schema
-        removeNullFormats(toolDef.function.parameters);
+        // recursively normalize provider-incompatible schema fragments
+        normalizeToolParameterSchema(toolDef.function.parameters);
         // OPEN AI models don't support strict mode well with schema with complex properties, so we disable it
         const model = getCurrentModel();
         if (model.provider === 'openai' || model.provider === 'azure_openai') {
@@ -689,7 +732,6 @@ export function formatScriptLintResult(lintResult) {
     }
     return response;
 }
-// ============= Workspace Runnables Search =============
 export class WorkspaceRunnablesSearch {
     uf;
     scriptsWorkspace = undefined;

package/package/components/copilot/chat/tokenUsage.d.ts

@@ -0,0 +1,23 @@
+export interface ChatTokenUsage {
+    prompt: number;
+    completion: number;
+    total: number;
+}
+export declare function emptyChatTokenUsage(): ChatTokenUsage;
+export declare function addChatTokenUsage(total: ChatTokenUsage, usage: ChatTokenUsage | null | undefined): ChatTokenUsage;
+export declare function anthropicUsageToChatTokenUsage(usage: {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_creation_input_tokens?: number | null;
+    cache_read_input_tokens?: number | null;
+} | null | undefined): ChatTokenUsage;
+export declare function openAIResponsesUsageToChatTokenUsage(usage: {
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    total_tokens?: number | null;
+} | null | undefined): ChatTokenUsage;
+export declare function openAICompletionsUsageToChatTokenUsage(usage: {
+    prompt_tokens?: number | null;
+    completion_tokens?: number | null;
+    total_tokens?: number | null;
+} | null | undefined): ChatTokenUsage;

package/package/components/copilot/chat/tokenUsage.js

@@ -0,0 +1,42 @@
+export function emptyChatTokenUsage() {
+    return { prompt: 0, completion: 0, total: 0 };
+}
+export function addChatTokenUsage(total, usage) {
+    if (!usage) {
+        return total;
+    }
+    return {
+        prompt: total.prompt + usage.prompt,
+        completion: total.completion + usage.completion,
+        total: total.total + usage.total
+    };
+}
+export function anthropicUsageToChatTokenUsage(usage) {
+    const prompt = (usage?.input_tokens ?? 0) +
+        (usage?.cache_creation_input_tokens ?? 0) +
+        (usage?.cache_read_input_tokens ?? 0);
+    const completion = usage?.output_tokens ?? 0;
+    return {
+        prompt,
+        completion,
+        total: prompt + completion
+    };
+}
+export function openAIResponsesUsageToChatTokenUsage(usage) {
+    const prompt = usage?.input_tokens ?? 0;
+    const completion = usage?.output_tokens ?? 0;
+    return {
+        prompt,
+        completion,
+        total: usage?.total_tokens ?? prompt + completion
+    };
+}
+export function openAICompletionsUsageToChatTokenUsage(usage) {
+    const prompt = usage?.prompt_tokens ?? 0;
+    const completion = usage?.completion_tokens ?? 0;
+    return {
+        prompt,
+        completion,
+        total: usage?.total_tokens ?? prompt + completion
+    };
+}

package/package/components/copilot/lib.d.ts

@@ -7,6 +7,7 @@ import { type Writable } from 'svelte/store';
 import { type Script } from '../../gen';
 import { type Tool, type ToolCallbacks } from './chat/shared';
 import type { Stream } from 'openai/core/streaming.mjs';
+import { type ChatTokenUsage } from './chat/tokenUsage';
 export declare const SUPPORTED_LANGUAGES: Set<string>;
 interface AIProviderDetails {
     label: string;
@@ -103,7 +104,10 @@ export declare function parseOpenAICompletion(completion: Stream<ChatCompletionC
 }, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, _abortController?: AbortController, // unused, for signature compatibility with parseAnthropicCompletion
 options?: {
     workspace?: string;
-}): Promise<boolean>;
+}): Promise<{
+    shouldContinue: boolean;
+    tokenUsage: ChatTokenUsage;
+}>;
 export declare function getResponseFromEvent(part: OpenAI.Chat.Completions.ChatCompletionChunk): string;
 export declare function copilot(scriptOptions: CopilotOptions, generatedCode: Writable<string>, abortController: AbortController, generatedExplanation?: Writable<string>): Promise<string>;
 export {};

package/package/components/copilot/lib.js

@@ -11,6 +11,7 @@ import { getNonStreamingOpenAIResponsesCompletion, getOpenAIResponsesCompletionS
 import { convertOpenAIToAnthropicMessages } from './chat/anthropic';
 import { generateRandomString } from '../../utils';
 import { copilotInfo, getCurrentModel } from '../../aiStore';
+import { emptyChatTokenUsage, openAICompletionsUsageToChatTokenUsage } from './chat/tokenUsage';
 export const SUPPORTED_LANGUAGES = new Set(Object.keys(GEN_CONFIG.prompts));
 const OPENAI_MODELS = [
     'gpt-5',
@@ -309,7 +310,7 @@ export function createOpenAIProxyClient(baseURL) {
         baseURL,
         apiKey: 'fake-key',
         defaultHeaders: {
-            Authorization: '' // a non empty string will be unable to access Windmill backend proxy
+            Authorization: OpenAPI.TOKEN ? `Bearer ${OpenAPI.TOKEN}` : ''
         },
         dangerouslyAllowBrowser: true
     });
@@ -318,7 +319,8 @@ export function createAnthropicProxyClient(baseURL) {
     return new Anthropic({
         baseURL,
         apiKey: 'fake-key',
-        dangerouslyAllowBrowser: true
+        dangerouslyAllowBrowser: true,
+        defaultHeaders: OpenAPI.TOKEN ? { Authorization: `Bearer ${OpenAPI.TOKEN}` } : undefined
     });
 }
 class WorkspacedAIClients {
@@ -653,7 +655,17 @@ export async function getCompletion(messages, abortController, tools, options) {
     }
     // Use Completions API for other providers
     const client = options?.openaiClient ?? workspaceAIClients.getOpenaiClient();
-    const completion = client.chat.completions.create(config, {
+    const completionConfig = (provider === 'openai' || provider === 'azure_openai' || provider === 'googleai') &&
+        config.stream
+        ? {
+            ...config,
+            stream_options: {
+                ...(config.stream_options ?? {}),
+                include_usage: true
+            }
+        }
+        : config;
+    const completion = client.chat.completions.create(completionConfig, {
         signal: abortController.signal,
         headers: {
             'X-Provider': provider
@@ -675,8 +687,12 @@ export async function parseOpenAICompletion(completion, callbacks, messages, add
 options) {
     const finalToolCalls = {};
     let malformedFunctionCallError = false;
+    let tokenUsage = emptyChatTokenUsage();
     let answer = '';
     for await (const chunk of completion) {
+        if ('usage' in chunk && chunk.usage) {
+            tokenUsage = openAICompletionsUsageToChatTokenUsage(chunk.usage);
+        }
         if (!('choices' in chunk && chunk.choices.length > 0 && 'delta' in chunk.choices[0])) {
             continue;
         }
@@ -835,9 +851,9 @@ options) {
         addedMessages.push(toolResponse);
     }
     else {
-        return false;
+        return { shouldContinue: false, tokenUsage };
     }
-    return true;
+    return { shouldContinue: true, tokenUsage };
 }
 export function getResponseFromEvent(part) {
     return part.choices?.[0]?.delta?.content || '';