windmill-components 1.558.4 → 1.596.0

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

@@ -3,25 +3,20 @@ import { capitalize, isObject, toCamel } from '../../../../utils';
 import { get } from 'svelte/store';
 import { compile, phpCompile, pythonCompile } from '../../utils';
 import { dbSchemas } from '../../../../stores';
-import { getDbSchemas } from '../../../apps/components/display/dbtable/utils';
-import { PYTHON_PREPROCESSOR_MODULE_CODE, TS_PREPROCESSOR_MODULE_CODE } from '../../../../script_helpers';
 import { createSearchHubScriptsTool, executeTestRun, buildTestRunArgs, buildContextString } from '../shared';
 import { setupTypeAcquisition } from '../../../../ata';
 import { getModelContextWindow } from '../../lib';
 import { getCurrentModel } from '../../../../aiStore';
+import { getDbSchemas } from '../../../apps/components/display/dbtable/metadata';
+import { getScriptPrompt } from '../../../../../../../system_prompts/auto-generated';
 // Score threshold for npm packages search filtering
 const SCORE_THRESHOLD = 1000;
 // percentage of the context window for documentation of npm packages
 const DOCS_CONTEXT_PERCENTAGE = 1;
 // percentage of the context window for types of npm packages
 const TYPES_CONTEXT_PERCENTAGE = 1;
-// good providers for diff-based edit
-export const DIFF_BASED_EDIT_PROVIDERS = [
-    'openai',
-    'anthropic',
-    'googleai',
-    'azure_openai'
-];
+// TODO: Explore this again when we have better diff-based edit providers
+export const DIFF_BASED_EDIT_PROVIDERS = [];
 export function formatResourceTypes(allResourceTypes, lang) {
     const resourceTypes = allResourceTypes.filter((rt) => isObject(rt.schema) && 'properties' in rt.schema && isObject(rt.schema.properties));
     if (lang === 'python3') {
@@ -52,109 +47,6 @@ async function getResourceTypes(prompt, workspace) {
     });
     return resourceTypes;
 }
-const TS_RESOURCE_TYPE_SYSTEM = `On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-If you need credentials, you should add a parameter to \`main\` with the corresponding resource type inside the \`RT\` namespace: for instance \`RT.Stripe\`.
-You should only use them if you need them to satisfy the user's instructions. Always use the RT namespace.\n`;
-const TS_WINDMILL_CLIENT_CONTEXT = `
-
-The windmill client (wmill) can be used to interact with Windmill from the script. Import it with \`import * as wmill from "windmill-client"\`. Key functions include:
-
-// Resource operations
-wmill.getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any> // Get resource value by path
-wmill.setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void> // Set resource value
-
-// State management (persistent across executions)  
-wmill.getState(): Promise<any> // Get shared state
-wmill.setState(state: any): Promise<void> // Set shared state
-
-// Variables
-wmill.getVariable(path: string): Promise<string> // Get variable value
-wmill.setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void> // Set variable value
-
-// Script execution
-wmill.runScript(path?: string | null, hash_?: string | null, args?: Record<string, any> | null, verbose?: boolean): Promise<any> // Run script synchronously
-wmill.runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds?: number | null): Promise<string> // Run script async, returns job ID
-wmill.waitJob(jobId: string, verbose?: boolean): Promise<any> // Wait for job completion and get result
-wmill.getResult(jobId: string): Promise<any> // Get job result by ID
-wmill.getResultMaybe(jobId: string): Promise<any> // Get job result by ID, returns undefined if not found
-wmill.getRootJobId(jobId?: string): Promise<string> // Get root job ID from job ID
-
-// S3 file operations (if S3 is configured)
-wmill.loadS3File(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Uint8Array | undefined> // Load file content from S3
-wmill.loadS3FileStream(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Blob | undefined> // Load file content from S3 as stream
-wmill.writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath?: string | undefined): Promise<S3Object> // Write file to S3
-
-// Flow operations
-wmill.setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void> // Set flow user state
-wmill.getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any> // Get flow user state
-wmill.getResumeUrls(approver?: string): Promise<{approvalPage: string, resume: string, cancel: string}> // Get approval URLs
-
-`;
-const PYTHON_WINDMILL_CLIENT_CONTEXT = `
-
-The windmill client (wmill) can be used to interact with Windmill from the script. Import it with \`import wmill\`. Key functions include:
-
-// Resource operations
-wmill.get_resource(path: str, none_if_undefined: bool = False) -> dict | None  // Get resource value by path
-wmill.set_resource(path: str, value: Any, resource_type: str = "any") -> None  // Set resource value
-
-// State management (persistent across executions)
-wmill.get_state() -> Any  // Get shared state (deprecated, use flow user state)
-wmill.set_state(value: Any) -> None  // Set shared state
-wmill.get_state_path() -> str  // Get state path
-wmill.get_flow_user_state(key: str) -> Any  // Get flow user state 
-wmill.set_flow_user_state(key: str, value: Any) -> None  // Set flow user state
-
-// Variables
-wmill.get_variable(path: str) -> str  // Get variable value
-wmill.set_variable(path: str, value: str, is_secret: bool = False) -> None  // Set variable value
-
-// Script execution
-wmill.run_script(path: str = None, hash_: str = None, args: dict = None, timeout = None, verbose: bool = False, cleanup: bool = True, assert_result_is_not_none: bool = True) -> Any  // Run script synchronously
-wmill.run_script_async(path: str = None, hash_: str = None, args: dict = None, scheduled_in_secs: int = None) -> str  // Run script async, returns job ID
-wmill.wait_job(job_id: str, timeout = None, verbose: bool = False, cleanup: bool = True, assert_result_is_not_none: bool = False) -> Any  // Wait for job completion and get result
-wmill.get_result(job_id: str, assert_result_is_not_none: bool = True) -> Any  // Get job result by ID
-wmill.get_root_job_id(job_id: str | None = None) -> str  // Get root job ID from job ID
-
-// S3 file operations (if S3 is configured)
-wmill.load_s3_file(s3object: S3Object | str, s3_resource_path: str | None = None) -> bytes  // Load file content from S3
-wmill.load_s3_file_reader(s3object: S3Object | str, s3_resource_path: str | None = None) -> BufferedReader  // Load S3 file as stream reader
-wmill.write_s3_file(s3object: S3Object | str | None, file_content: BufferedReader | bytes, s3_resource_path: str | None = None, content_type: str | None = None, content_disposition: str | None = None) -> S3Object  // Write file to S3
-
-// Flow operations  
-wmill.run_flow_async(path: str, args: dict = None, scheduled_in_secs: int = None, do_not_track_in_parent: bool = True) -> str  // Run flow asynchronously
-wmill.get_resume_urls(approver: str = None) -> dict  // Get approval URLs for flow steps
-
-// Utilities
-wmill.get_workspace() -> str  // Get current workspace
-wmill.whoami() -> dict  // Get current user information
-wmill.get_job_status(job_id: str) -> str  // Get job status ("RUNNING" | "WAITING" | "COMPLETED")
-wmill.set_progress(value: int, job_id: Optional[str] = None) -> None  // Set job progress (0-100)
-wmill.get_progress(job_id: Optional[str] = None) -> Any  // Get job progress`;
-const PYTHON_RESOURCE_TYPE_SYSTEM = `On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-If you need credentials, you should add a parameter to \`main\` with the corresponding resource type.
-You need to **redefine** the type of the resources that are needed before the main function as TypedDict, but only include them if they are actually needed to achieve the function purpose.
-The resource type name has to be exactly as specified (has to be IN LOWERCASE).
-If an import conflicts with a resource type name, **you have to rename the imported object, not the type name**.
-Make sure to import TypedDict from typing **if you're using it**`;
-const PHP_RESOURCE_TYPE_SYSTEM = `On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
-If you need credentials, you should add a parameter to \`main\` with the corresponding resource type
-You need to **redefine** the type of the resources that are needed before the main function, but only include them if they are actually needed to achieve the function purpose.
-Before defining each type, check if the class already exists using class_exists.
-The resource type name has to be exactly as specified.`;
-const PREPROCESSOR_INSTRUCTION_BASE = `The current script is a preprocessor. It processes raw trigger data from various sources (webhook, custom HTTP route, SQS, WebSocket, Kafka, NATS, MQTT, Postgres, or email) before passing it to the flow. This separates the trigger logic from the flow logic and keeps the auto-generated UI clean.
-The returned object determines the parameter values passed to the flow.
-e.g., \`{ b: 1, a: 2 }\` → Calls the flow with \`a = 2\` and \`b = 1\`, assuming the flow has two inputs called \`a\` and \`b\`.
-The preprocessor receives a single parameter called event.
-Here's a sample script which includes the event object definition:\n`;
-const TS_PREPROCESSOR_INSTRUCTION = PREPROCESSOR_INSTRUCTION_BASE +
-    `\`\`\`typescript
-${TS_PREPROCESSOR_MODULE_CODE}
-\`\`\`\n`;
-const PYTHON_PREPROCESSOR_INSTRUCTION = PREPROCESSOR_INSTRUCTION_BASE +
-    `\`\`\`python
-${PYTHON_PREPROCESSOR_MODULE_CODE}
-\`\`\``;
 export const SUPPORTED_CHAT_SCRIPT_LANGUAGES = [
     'bunnative',
     'nativets',
@@ -173,95 +65,24 @@ export const SUPPORTED_CHAT_SCRIPT_LANGUAGES = [
     'graphql',
     'powershell',
     'csharp',
-    'java'
+    'java',
+    'duckdb'
 ];
 export function getLangContext(lang, { allowResourcesFetch = false, isPreprocessor = false } = {}) {
-    const tsContext = (isPreprocessor
-        ? TS_PREPROCESSOR_INSTRUCTION
-        : TS_RESOURCE_TYPE_SYSTEM +
-            (allowResourcesFetch
-                ? `To query the RT namespace, you can use the \`search_resource_types\` tool.\n`
-                : '')) + TS_WINDMILL_CLIENT_CONTEXT;
-    const mainFunctionName = isPreprocessor ? 'preprocessor' : 'main';
-    switch (lang) {
-        case 'bunnative':
-        case 'nativets':
-            return (`The user is coding in TypeScript. On Windmill, it is expected that the script exports a single **async** function called \`${mainFunctionName}\`. You should use fetch (available globally, no need to import) and are not allowed to import any libraries.\n` +
-                tsContext);
-        case 'bun':
-            return (`The user is coding in TypeScript (bun runtime). On Windmill, it is expected that the script exports a single **async** function called \`${mainFunctionName}\`. Do not call the ${mainFunctionName} function. Libraries are installed automatically, do not show how to install them.\n` +
-                tsContext);
-        case 'deno':
-            return (`The user is coding in TypeScript (deno runtime). On Windmill, it is expected that the script exports a single **async** function called \`${mainFunctionName}\`. Do not call the ${mainFunctionName} function. Libraries are installed automatically, do not show how to install them.\n` +
-                tsContext +
-                '\nYou can import deno libraries or you can import npm libraries like that: `import ... from "npm:{package}";`.');
-        case 'python3':
-            return (`The user is coding in Python. On Windmill, it is expected the script contains at least one function called \`${mainFunctionName}\`. Do not call the ${mainFunctionName} function. Libraries are installed automatically, do not show how to install them.` +
-                (isPreprocessor
-                    ? PYTHON_PREPROCESSOR_INSTRUCTION
-                    : PYTHON_RESOURCE_TYPE_SYSTEM +
-                        `${allowResourcesFetch ? `\nTo query the available resource types, you can use the \`search_resource_types\` tool.` : ''}`) +
-                PYTHON_WINDMILL_CLIENT_CONTEXT);
-        case 'php':
-            return ('The user is coding in PHP. On Windmill, it is expected the script contains at least one function called `main`. The script must start with <?php.' +
-                PHP_RESOURCE_TYPE_SYSTEM +
-                `${allowResourcesFetch ? `\nTo query the available resource types, you can use the \`search_resource_types\` tool.` : ''}` +
-                `\nIf you need to import libraries, you need to specify them as comments in the following manner before the main function:
-					\`\`\`
-					// require:
-					// mylibrary/mylibrary
-					// myotherlibrary/myotherlibrary@optionalversion
-					\`\`\`
-					Make sure to have one per line.
-					No need to require autoload, it is already done.`);
-        case 'rust':
-            return `The user is coding in Rust. On Windmill, it is expected the script contains at least one function called \`main\` (without calling it) defined like this:
-				\`\`\`rust
-				use anyhow::anyhow;
-				use serde::Serialize;
-
-				#[derive(Serialize, Debug)]
-				struct ReturnType {
-					// ...
-				}
-
-				fn main(...) -> anyhow::Result<ReturnType>
-				\`\`\`
-				Arguments should be owned. Make sure the return type is serializable.
-
-				Packages must be made available with a partial cargo.toml by adding the following comment at the beginning of the script:
-				//! \`\`\`cargo
-				//! [dependencies]
-				//! anyhow = "1.0.86"
-				//! \`\`\'
-				Serde is already included, no need to add it again.
-
-				If you want to handle async functions (e.g., using tokio), you need to keep the main function sync and create the runtime inside.`;
-        case 'go':
-            return `The user is coding in Go. On Windmill, it is expected the script exports a single function called \`main\`. Its return type has to be (\`{return_type}\`, error). The file package has to be "inner".`;
-        case 'bash':
-            return `The user is coding in Bash. Do not include "#!/bin/bash". On Windmill, arguments are always string and can only be obtained with "var1="$1"", "var2="$2"", etc..`;
-        case 'postgresql':
-            return `The user is coding in PostgreSQL. On Windmill, arguments can be obtained directly in the statement with \`$1::{type}\`, \`$2::{type}\`, etc... Name the parameters (without specifying the type) by adding comments at the beginning of the script before the statement like that: \`-- $1 name1\` or \`-- $2 name = default\` (one per row)`;
-        case 'mysql':
-            return 'The user is coding in MySQL. On Windmill, arguments can be obtained directly in the statement with ?. Name the parameters by adding comments before the statement like that: `-- ? name1 ({type})` or `-- ? name2 ({type}) = default` (one per row)';
-        case 'bigquery':
-            return 'The user is coding in BigQuery. On Windmill, arguments can be obtained by adding comments before the statement like that: `-- @name1 ({type})` or `-- @name2 ({type}) = default` (one per row). They can then be obtained directly in the statement with `@name1`, `@name2`, etc....';
-        case 'snowflake':
-            return 'The user is coding in Snowflake. On Windmill, arguments can be obtained directly in the statement with ?. Name the parameters by adding comments before the statement like that: `-- ? name1 ({type})` or `-- ? name2 ({type}) = default` (one per row)';
-        case 'mssql':
-            return 'The user is coding in Microsoft SQL Server. On Windmill, arguments can be obtained directly in the statement with @P1, @P2, etc.. Name the parameters by adding comments before the statement like that: `-- @P1 name1 ({type})` or `-- @P2 name2 ({type}) = default` (one per row)';
-        case 'graphql':
-            return 'The user is coding in GraphQL. If needed, add the needed arguments as query parameters.';
-        case 'powershell':
-            return 'The user is coding in PowerShell. On Windmill, arguments can be obtained by calling the param function on the first line of the script like that: `param($ParamName1, $ParamName2 = "default value", [{type}]$ParamName3, ...)`';
-        case 'csharp':
-            return 'The user is coding in C#. On Windmill, it is expected the script contains a public static Main method inside a class. The class name is irrelevant. NuGet packages can be added using the format: #r "nuget: PackageName, Version" at the top of the script. The Main method signature should be: public static ReturnType Main(parameter types...)';
-        case 'java':
-            return 'The user is coding in Java. On Windmill, it is expected the script contains a Main public class and a public static main() method. The return type can be Object or void. Dependencies can be added using the format: //requirements://groupId:artifactId:version at the top of the script. The method signature should be: public static Object main(parameter types...)';
-        default:
-            return '';
+    // Get base language context from centralized prompts
+    let context = getScriptPrompt(lang);
+    // Add tool usage instructions for applicable languages
+    if (['python3', 'php', 'bun', 'deno', 'nativets', 'bunnative'].includes(lang)) {
+        if (allowResourcesFetch) {
+            context += '\n\nTo query available resource types, use the `search_resource_types` tool.';
+        }
     }
+    // Note preprocessor function naming if applicable
+    if (isPreprocessor) {
+        context +=
+            '\n\nThe main function for this script should be named `preprocessor` instead of `main`.';
+    }
+    return context;
 }
 export async function getFormattedResourceTypes(lang, prompt, workspace) {
     switch (lang) {
@@ -401,17 +222,20 @@ export async function main() {
 </new_code>
 \`\`\`
 `;
+export function prepareInlineChatSystemPrompt(lang) {
+    return INLINE_CHAT_SYSTEM_PROMPT + getLangContext(lang, { allowResourcesFetch: true });
+}
 export const CHAT_USER_PROMPT = `
 INSTRUCTIONS:
 {instructions}
 
-WINDMILL LANGUAGE CONTEXT:
-{lang_context}
-
 `;
-export function prepareScriptSystemMessage(currentModel, customPrompt) {
+export function prepareScriptSystemMessage(currentModel, language, options = {}, customPrompt) {
     let content = buildChatSystemPrompt(currentModel);
-    // If there's a custom prompt, prepend it to the system prompt
+    // Add language context to the system prompt
+    const langContext = getLangContext(language, { allowResourcesFetch: true, ...options });
+    content += `\n\nWINDMILL LANGUAGE CONTEXT:\n${langContext}`;
+    // If there's a custom prompt, append it to the system prompt
     if (customPrompt?.trim()) {
         content = `${content}\n\nUSER GIVEN INSTRUCTIONS:\n${customPrompt.trim()}`;
     }
@@ -442,8 +266,8 @@ export function prepareScriptTools(currentModel, language, context) {
     tools.push(testRunScriptTool);
     return tools;
 }
-export function prepareScriptUserMessage(instructions, language, selectedContext, options = {}) {
-    let userMessage = CHAT_USER_PROMPT.replace('{instructions}', instructions).replace('{lang_context}', getLangContext(language, { allowResourcesFetch: true, ...options }));
+export function prepareScriptUserMessage(instructions, selectedContext) {
+    let userMessage = CHAT_USER_PROMPT.replace('{instructions}', instructions);
     const contextInstructions = buildContextString(selectedContext);
     userMessage += contextInstructions;
     return {
@@ -745,6 +569,9 @@ const TEST_RUN_SCRIPT_TOOL = {
 };
 export const editCodeToolWithDiff = {
     def: EDIT_CODE_TOOL_WITH_DIFF,
+    streamArguments: true,
+    showDetails: true,
+    showFade: true,
     fn: async function ({ args, helpers, toolCallbacks, toolId }) {
         const scriptOptions = helpers.getScriptOptions();
         if (!scriptOptions) {
@@ -784,7 +611,8 @@ export const editCodeToolWithDiff = {
             // Show revert mode
             await helpers.applyCode(oldCode, { mode: 'revert' });
             toolCallbacks.setToolStatus(toolId, {
-                content: `Code changes applied`
+                content: `Code changes applied`,
+                result: 'Success'
             });
             return `Applied changes to the script editor.`;
         }
@@ -800,6 +628,9 @@ export const editCodeToolWithDiff = {
 };
 export const editCodeTool = {
     def: EDIT_CODE_TOOL,
+    streamArguments: true,
+    showDetails: true,
+    showFade: true,
     fn: async function ({ args, helpers, toolCallbacks, toolId }) {
         const scriptOptions = helpers.getScriptOptions();
         if (!scriptOptions) {
@@ -816,7 +647,6 @@ export const editCodeTool = {
             });
             throw new Error('Code parameter is required and must be a string');
         }
-        toolCallbacks.setToolStatus(toolId, { content: 'Applying code changes...' });
         try {
             // Save old code
             const oldCode = scriptOptions.code;
@@ -824,7 +654,10 @@ export const editCodeTool = {
             await helpers.applyCode(args.code, { applyAll: true, mode: 'apply' });
             // Show revert mode
             await helpers.applyCode(oldCode, { mode: 'revert' });
-            toolCallbacks.setToolStatus(toolId, { content: 'Code changes applied' });
+            toolCallbacks.setToolStatus(toolId, {
+                content: 'Code changes applied',
+                result: 'Success'
+            });
             return 'Code has been applied to the script editor.';
         }
         catch (error) {

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

@@ -1,9 +1,21 @@
 import type { ChatCompletionFunctionTool, ChatCompletionMessageFunctionToolCall, ChatCompletionMessageParam } from 'openai/resources/chat/completions.mjs';
+/**
+ * Special module IDs used throughout the flow system
+ */
+export declare const SPECIAL_MODULE_IDS: {
+    /** The flow input schema node */
+    readonly INPUT: "Input";
+    /** The preprocessor module that runs before the flow */
+    readonly PREPROCESSOR: "preprocessor";
+    /** The failure handler module */
+    readonly FAILURE: "failure";
+};
 import type { ContextElement, FlowModuleCodePieceElement } from './context';
 import type { ExtendedOpenFlow } from '../../flows/types';
 import type { FunctionParameters } from 'openai/resources/shared.mjs';
 import { z } from 'zod';
 import { type CompletedJob, type FlowModule } from '../../../gen';
+export declare const TOOL_PRETTIFY_MAP: Record<string, (content: string) => string>;
 export interface ContextStringResult {
     dbContext: string;
     diffContext: string;
@@ -19,7 +31,13 @@ export declare function buildContextString(selectedContext: ContextElement[]): s
 type BaseDisplayMessage = {
     content: string;
     contextElements?: ContextElement[];
-    snapshot?: ExtendedOpenFlow;
+    snapshot?: {
+        type: 'flow';
+        value: ExtendedOpenFlow;
+    } | {
+        type: 'app';
+        value: number;
+    };
 };
 export type UserDisplayMessage = BaseDisplayMessage & {
     role: 'user';
@@ -37,6 +55,9 @@ export type ToolDisplayMessage = {
     error?: string;
     needsConfirmation?: boolean;
     showDetails?: boolean;
+    isStreamingArguments?: boolean;
+    toolName?: string;
+    showFade?: boolean;
 };
 export type AssistantDisplayMessage = BaseDisplayMessage & {
     role: 'assistant';
@@ -65,12 +86,17 @@ export interface Tool<T> {
     requiresConfirmation?: boolean;
     confirmationMessage?: string;
     showDetails?: boolean;
+    streamArguments?: boolean;
+    showFade?: boolean;
 }
 export interface ToolCallbacks {
     setToolStatus: (id: string, metadata?: Partial<ToolDisplayMessage>) => void;
+    removeToolStatus: (id: string) => void;
     requestConfirmation?: (toolId: string) => Promise<boolean>;
 }
-export declare function createToolDef(zodSchema: z.ZodSchema, name: string, description: string): ChatCompletionFunctionTool;
+export declare function createToolDef(zodSchema: z.ZodSchema, name: string, description: string, { strict }?: {
+    strict?: boolean;
+}): ChatCompletionFunctionTool;
 export declare const createSearchHubScriptsTool: (withContent?: boolean) => {
     def: ChatCompletionFunctionTool;
     fn: ({ args, toolId, toolCallbacks }: {

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

@@ -1,11 +1,133 @@
+/**
+ * Special module IDs used throughout the flow system
+ */
+export const SPECIAL_MODULE_IDS = {
+    /** The flow input schema node */
+    INPUT: 'Input',
+    /** The preprocessor module that runs before the flow */
+    PREPROCESSOR: 'preprocessor',
+    /** The failure handler module */
+    FAILURE: 'failure'
+};
 import { get } from 'svelte/store';
 import { workspaceStore } from '../../../stores';
-import { zodToJsonSchema } from 'zod-to-json-schema';
 import { z } from 'zod';
 import { ScriptService, JobService } from '../../../gen';
 import { scriptLangToEditorLang } from '../../../scripts';
-import YAML from 'yaml';
 import { getCurrentModel } from '../../../aiStore';
+// Prettify function for code arguments - extracts and formats code from JSON
+function prettifyCodeArguments(content) {
+    let codeContent = content;
+    // If it's a JSON string, try to extract the code property
+    if (typeof content === 'string' && content.trim().startsWith('{')) {
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed.code) {
+                codeContent = parsed.code;
+            }
+        }
+        catch {
+            // If JSON is incomplete during streaming, try to extract manually
+            // Remove leading { "code": " or {"code":"
+            codeContent = content.replace(/^\{\s*"code"\s*:\s*"/, '');
+            // Remove trailing } if it exists
+            codeContent = codeContent.replace(/"\s*}\s*$/, '');
+        }
+    }
+    // Convert escaped newlines to actual newlines
+    codeContent = codeContent.replace(/\\n/g, '\n');
+    // Convert other common escape sequences
+    codeContent = codeContent.replace(/\\t/g, '\t');
+    codeContent = codeContent.replace(/\\"/g, '"');
+    codeContent = codeContent.replace(/\\\\/g, '\\');
+    return codeContent;
+}
+// Prettify function for set_module_code - extracts code from moduleId/code JSON
+function prettifySetModuleCode(content) {
+    let codeContent = content;
+    if (typeof content === 'string' && content.trim().startsWith('{')) {
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed.code) {
+                codeContent = parsed.code;
+            }
+        }
+        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];
+            }
+        }
+    }
+    // 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;
+}
+// Prettify function for module value JSON - extracts the 'value' property and formats it
+function prettifyModuleValue(content) {
+    try {
+        const parsed = JSON.parse(content);
+        // Extract just the 'value' property (the actual module definition)
+        if (parsed.value) {
+            return JSON.stringify(parsed.value, null, 2);
+        }
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch {
+        // If JSON is incomplete during streaming, try to extract the value property manually
+        const valueMatch = content.match(/"value"\s*:\s*(\{[\s\S]*)$/);
+        if (valueMatch) {
+            let valueContent = valueMatch[1];
+            // Try to parse and format the extracted value
+            try {
+                // Find the matching closing brace for the value object
+                let braceCount = 0;
+                let endIndex = 0;
+                for (let i = 0; i < valueContent.length; i++) {
+                    if (valueContent[i] === '{')
+                        braceCount++;
+                    else if (valueContent[i] === '}')
+                        braceCount--;
+                    if (braceCount === 0) {
+                        endIndex = i + 1;
+                        break;
+                    }
+                }
+                if (endIndex > 0) {
+                    const valueJson = valueContent.substring(0, endIndex);
+                    const parsed = JSON.parse(valueJson);
+                    return JSON.stringify(parsed, null, 2);
+                }
+            }
+            catch {
+                // If parsing fails, just unescape and return the extracted value content
+                valueContent = valueContent.replace(/\\n/g, '\n');
+                valueContent = valueContent.replace(/\\t/g, '\t');
+                valueContent = valueContent.replace(/\\"/g, '"');
+                valueContent = valueContent.replace(/\\\\/g, '\\');
+                return valueContent;
+            }
+        }
+        // Fallback: just unescape and return
+        let result = content;
+        result = result.replace(/\\n/g, '\n');
+        result = result.replace(/\\t/g, '\t');
+        result = result.replace(/\\"/g, '"');
+        result = result.replace(/\\\\/g, '\\');
+        return result;
+    }
+}
+// Map of tool names to their prettify functions
+export const TOOL_PRETTIFY_MAP = {
+    edit_code: prettifyCodeArguments,
+    set_module_code: prettifySetModuleCode,
+    add_module: prettifyModuleValue,
+    modify_module: prettifyModuleValue
+};
 export const extractAllModules = (modules) => {
     return modules.flatMap((m) => {
         if (m.value.type === 'forloopflow' || m.value.type === 'whileloopflow') {
@@ -83,7 +205,7 @@ export function applyCodePiecesToFlowModules(codePieces, flowModules) {
             module.value.content = applyCodePieceToCodeContext(pieces, module.value.content);
         }
     }
-    return YAML.stringify(modifiedModules);
+    return JSON.stringify(modifiedModules, null, 2);
 }
 export function buildContextString(selectedContext) {
     const dbTemplate = `- {title}: SCHEMA: \n{schema}\n`;
@@ -169,7 +291,6 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks
         const tool = tools.find((t) => t.def.function.name === toolCall.function.name);
         // Check if tool requires confirmation
         const needsConfirmation = tool?.requiresConfirmation;
-        // Add the tool to the display with appropriate status
         toolCallbacks.setToolStatus(toolCall.id, {
             ...(tool?.requiresConfirmation
                 ? { content: tool.confirmationMessage ?? 'Waiting for confirmation...' }
@@ -222,7 +343,11 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks
                 isLoading: false,
                 error: 'An error occurred while calling the tool'
             });
-            const errorMessage = typeof err === 'string' ? err : 'An error occurred while calling the tool';
+            const errorMessage = typeof err === 'object' && 'message' in err
+                ? err.message
+                : typeof err === 'string'
+                    ? err
+                    : 'An error occurred while calling the tool';
             result = `Error while calling tool: ${errorMessage}`;
         }
         const toAdd = {
@@ -241,20 +366,17 @@ export async function processToolCall({ tools, toolCall, helpers, toolCallbacks
         };
     }
 }
-export function createToolDef(zodSchema, name, description) {
-    const schema = zodToJsonSchema(zodSchema, {
-        name,
-        target: 'openAi'
-    });
-    let parameters = schema.definitions[name];
-    parameters = {
-        ...parameters,
-        required: parameters.required ?? []
-    };
+export function createToolDef(zodSchema, name, description, { strict = true } = {} // we sometimes have to set strict to false for open ai models to avoid issues with complex properties
+) {
+    // console.log('creating tool def for', name, zodSchema)
+    let parameters = z.toJSONSchema(zodSchema);
+    delete parameters.$schema;
+    if (!parameters.required)
+        parameters.required = [];
     return {
         type: 'function',
         function: {
-            strict: true,
+            strict,
             name,
             description,
             parameters
@@ -298,6 +420,40 @@ export const createSearchHubScriptsTool = (withContent = false) => ({
         return JSON.stringify(results);
     }
 });
+/**
+ * Recursively removes format: null or format: '' from a JSON schema object
+ */
+function removeNullFormats(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    // Remove format if it's null or empty string
+    if (schema.format === null || schema.format === '') {
+        delete schema.format;
+    }
+    // Recurse into properties
+    if (schema.properties && typeof schema.properties === 'object') {
+        for (const key of Object.keys(schema.properties)) {
+            removeNullFormats(schema.properties[key]);
+        }
+    }
+    // Recurse into items (for arrays)
+    if (schema.items) {
+        removeNullFormats(schema.items);
+    }
+    // Recurse into additionalProperties if it's an object schema
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        removeNullFormats(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);
+            }
+        }
+    }
+}
 export async function buildSchemaForTool(toolDef, schemaBuilder) {
     try {
         const schema = await schemaBuilder();
@@ -308,6 +464,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);
         // 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') {

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

@@ -87,12 +87,13 @@ export declare function getNonStreamingCompletion(messages: ChatCompletionMessag
 }): Promise<string>;
 export declare const FIM_MAX_TOKENS = 256;
 export declare function getFimCompletion(prompt: string, suffix: string, providerModel: AIProviderModel, abortController: AbortController): Promise<string | undefined>;
-export declare function getCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[]): Promise<Stream<ChatCompletionChunk>>;
+export declare function getCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, tools?: OpenAI.Chat.Completions.ChatCompletionTool[], options?: {
+    forceCompletions?: boolean;
+}): Promise<Stream<ChatCompletionChunk>>;
 export declare function parseOpenAICompletion(completion: Stream<ChatCompletionChunk>, callbacks: ToolCallbacks & {
     onNewToken: (token: string) => void;
     onMessageEnd: () => void;
-}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any): Promise<boolean>;
+}, messages: ChatCompletionMessageParam[], addedMessages: ChatCompletionMessageParam[], tools: Tool<any>[], helpers: any, _abortController?: AbortController): Promise<boolean>;
 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 declare function deltaCodeCompletion(messages: ChatCompletionMessageParam[], generatedCodeDelta: Writable<string>, abortController: AbortController): Promise<string>;
 export {};