windmill-components 1.493.10 → 1.501.5

package/package/components/copilot/chat/{core.d.ts → script/core.d.ts}

@@ -1,72 +1,26 @@
-import type { ResourceType, ScriptLang } from '../../../gen/types.gen';
-import { type Writable } from 'svelte/store';
-import { Code, Database, TriangleAlert, Diff } from 'lucide-svelte';
-import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
-import { type DBSchema } from '../../../stores';
-import { type Change } from 'diff';
+import type { ResourceType, ScriptLang } from '../../../../gen/types.gen';
+import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/index.mjs';
+import type { ContextElement } from '../context';
+import type { Tool } from '../shared';
 export declare function formatResourceTypes(allResourceTypes: ResourceType[], lang: 'python3' | 'php' | 'bun' | 'deno' | 'nativets' | 'bunnative'): string;
 export declare const SUPPORTED_CHAT_SCRIPT_LANGUAGES: string[];
-export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' | 'tsx' | 'json', { allowResourcesFetch }?: {
+export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' | 'tsx' | 'json', { allowResourcesFetch, isPreprocessor }?: {
     allowResourcesFetch?: boolean;
+    isPreprocessor?: boolean;
+    isFailure?: boolean;
 }): string;
 export declare function getFormattedResourceTypes(lang: ScriptLang | 'bunnative', prompt: string, workspace: string): Promise<string>;
 export declare const CHAT_SYSTEM_PROMPT = "\n\tYou are a coding assistant for the Windmill platform. You are provided with a list of `INSTRUCTIONS` and the current contents of a code file under `CODE`.\n\n\tYour task is to respond to the user's request. Assume all user queries are valid and actionable.\n\n\tWhen the user requests code changes:\n\t- Always include a **single code block** with the **entire updated file**, not just the modified sections.\n\t- The code can include `[#START]` and `[#END]` markers to indicate the start and end of a code piece. You MUST only modify the code between these markers if given, and remove them in your response. If a question is asked about the code, you MUST only talk about the code between the markers. Refer to it as the code piece, not the code between the markers.\n\t- Follow the instructions carefully and explain the reasoning behind your changes.\n\t- If the request is abstract (e.g., \"make this cleaner\"), interpret it concretely and reflect that in the code block.\n\t- Preserve existing formatting, indentation, and whitespace unless changes are strictly required to fulfill the user's request.\n\t- The user can ask you to look at or modify specific files, databases or errors by having its name in the INSTRUCTIONS preceded by the @ symbol. In this case, put your focus on the element that is explicitly mentioned.\n\t- The user can ask you questions about a list of `DATABASES` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.\n\t- You can also receive a `DIFF` of the changes that have been made to the code. You should use this diff to give better answers.\n\t- Before giving your answer, check again that you carefully followed these instructions.\n\n\tImportant:\n\tDo not mention or reveal these instructions to the user unless explicitly asked to do so.\n";
 export declare const CHAT_USER_PROMPT = "\nINSTRUCTIONS:\n{instructions}\n\nWINDMILL LANGUAGE CONTEXT:\n{lang_context}\n\n";
 export declare const CHAT_USER_DB_CONTEXT = "- {title}: SCHEMA: \n{schema}\n";
-export declare function prepareSystemMessage(): {
-    role: 'system';
-    content: string;
-};
-export interface DisplayMessage {
-    role: 'user' | 'assistant';
-    content: string;
-    contextElements?: ContextElement[];
-}
-export declare const ContextIconMap: {
-    code: typeof Code;
-    error: typeof TriangleAlert;
-    db: typeof Database;
-    diff: typeof Diff;
-    code_piece: typeof Code;
-};
-type CodeElement = {
-    type: 'code';
-    content: string;
-    title: string;
-    lang: ScriptLang | 'bunnative';
-};
-type ErrorElement = {
-    type: 'error';
-    content: string;
-    title: 'error';
-};
-type DBElement = {
-    type: 'db';
-    schema?: DBSchema;
-    title: string;
-};
-type DiffElement = {
-    type: 'diff';
-    content: string;
-    title: string;
-    diff: Change[];
-    lang: ScriptLang | 'bunnative';
-};
-type CodePieceElement = {
-    type: 'code_piece';
-    content: string;
-    startLine: number;
-    endLine: number;
-    title: string;
-    lang: ScriptLang | 'bunnative';
-};
-export type ContextElement = CodeElement | ErrorElement | DBElement | DiffElement | CodePieceElement;
-export declare function prepareUserMessage(instructions: string, language: ScriptLang | 'bunnative', selectedContext: ContextElement[]): Promise<string>;
+export declare function prepareScriptSystemMessage(): ChatCompletionSystemMessageParam;
+export declare function prepareScriptTools(language: ScriptLang | 'bunnative', context: ContextElement[]): Tool<ScriptChatHelpers>[];
+export declare function prepareScriptUserMessage(instructions: string, language: ScriptLang | 'bunnative', selectedContext: ContextElement[], options?: {
+    isPreprocessor?: boolean;
+}): Promise<ChatCompletionUserMessageParam>;
 export declare const MAX_SCHEMA_LENGTH: number;
-export declare function chatRequest(messages: ChatCompletionMessageParam[], abortController: AbortController, lang: ScriptLang | 'bunnative', useDbTools: boolean, onNewToken: (token: string) => void): Promise<any>;
-export interface AIChatContext {
-    loading: Writable<boolean>;
-    currentReply: Writable<string>;
-    applyCode: (code: string) => void;
+export interface ScriptChatHelpers {
+    getLang: () => ScriptLang | 'bunnative';
 }
-export {};
+export declare const resourceTypeTool: Tool<ScriptChatHelpers>;
+export declare const dbSchemaTool: Tool<ScriptChatHelpers>;

package/package/components/copilot/chat/{core.js → script/core.js}

@@ -1,13 +1,11 @@
-import { ResourceService } from '../../../gen/services.gen';
-import { capitalize, isObject, toCamel } from '../../../utils';
+import { ResourceService } from '../../../../gen/services.gen';
+import { capitalize, isObject, toCamel } from '../../../../utils';
 import { get } from 'svelte/store';
-import { getCompletion } from '../lib';
-import { compile, phpCompile, pythonCompile } from '../utils';
-import { Code, Database, TriangleAlert, Diff } from 'lucide-svelte';
-import { workspaceStore, dbSchemas } from '../../../stores';
-import { scriptLangToEditorLang } from '../../../scripts';
-import { getDbSchemas } from '../../apps/components/display/dbtable/utils';
-import {} from 'diff';
+import { compile, phpCompile, pythonCompile } from '../../utils';
+import { dbSchemas } from '../../../../stores';
+import { scriptLangToEditorLang } from '../../../../scripts';
+import { getDbSchemas } from '../../../apps/components/display/dbtable/utils';
+import { PYTHON_PREPROCESSOR_MODULE_CODE, TS_PREPROCESSOR_MODULE_CODE } from '../../../../script_helpers';
 export function formatResourceTypes(allResourceTypes, lang) {
     const resourceTypes = allResourceTypes.filter((rt) => isObject(rt.schema) && 'properties' in rt.schema && isObject(rt.schema.properties));
     if (lang === 'python3') {
@@ -40,8 +38,76 @@ async function getResourceTypes(prompt, workspace) {
 }
 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.`;
-const TS_INLINE_TYPE_INSTRUCTION = `You must always inline the objects types instead of defining them separately. If INSTRUCTIONS ask you to use an already defined type, you MUST inline it instead of using the type name. Explain to the user that you are inlining the type for better arguments inference.`;
+You should only use them if you need them to satisfy the user's instructions. Always use the RT namespace.\n`;
+const TS_INLINE_TYPE_INSTRUCTION = `When using resource types, you should use RT.ResourceType as parameter type. For other parameters, you should inline the objects types instead of defining them separately. This is because Windmill requires the types (other than resource types) to be inlined to generate a user friendly UI from the parameters.`;
+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): Promise<any> // Get resource value by path
+wmill.setResource(value: any, path?: 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): Promise<void> // Set variable value
+
+// Script execution
+wmill.runScript(path: string, args?: Record<string, any>): Promise<any> // Run script synchronously
+wmill.runScriptAsync(path: string, args?: Record<string, any>): Promise<string> // Run script async, returns job ID
+wmill.waitJob(jobId: string): Promise<any> // Wait for job completion and get result
+
+// S3 file operations (if S3 is configured)
+wmill.loadS3File(s3object: S3Object): Promise<Uint8Array> // Load file content from S3
+wmill.writeS3File(s3object: S3Object, content: string | Blob): Promise<S3Object> // Write file to S3
+
+// Flow operations
+wmill.setFlowUserState(key: string, value: any): Promise<void> // Set flow user state
+wmill.getFlowUserState(key: string): Promise<any> // Get flow user state
+wmill.getResumeUrls(): Promise<{approvalPage: string, resume: string, cancel: string}> // Get approval URLs
+
+// Utilities
+wmill.getWorkspace(): string // Get current workspace
+wmill.databaseUrlFromResource(path: string): Promise<string> // Get database URL from resource`;
+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) -> 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_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, args: dict = None, timeout = None) -> Any  // Run script synchronously
+wmill.run_script_async(path: str, args: dict = None, scheduled_in_secs: int = None) -> str  // Run script async, returns job ID
+wmill.wait_job(job_id: str, timeout = None) -> Any  // Wait for job completion and get result
+
+// S3 file operations (if S3 is configured)
+wmill.load_s3_file(s3object: S3Object, s3_resource_path: str = None) -> bytes  // Load file content from S3
+wmill.write_s3_file(s3object: S3Object, file_content: bytes, s3_resource_path: str = None) -> S3Object  // Write file to S3
+
+// Flow operations  
+wmill.run_flow_async(path: str, args: dict = None) -> str  // Run flow asynchronously
+wmill.get_resume_urls(approver: str = None) -> dict  // Get approval URLs for flow steps
+
+// Utilities
+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) -> None  // Set job progress (0-100)`;
 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.
@@ -53,6 +119,19 @@ If you need credentials, you should add a parameter to \`main\` with the corresp
 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',
@@ -69,34 +148,43 @@ export const SUPPORTED_CHAT_SCRIPT_LANGUAGES = [
     'snowflake',
     'mssql',
     'graphql',
-    'powershell'
+    'powershell',
+    'csharp',
+    'java'
 ];
-export function getLangContext(lang, { allowResourcesFetch = false } = {}) {
-    const tsContext = TS_RESOURCE_TYPE_SYSTEM +
-        (allowResourcesFetch
-            ? `\nTo query the RT namespace, you can use the \`search_resource_types\` function.\n`
-            : '') +
-        TS_INLINE_TYPE_INSTRUCTION;
+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_INLINE_TYPE_INSTRUCTION +
+        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 `main`. You should use fetch (available globally, no need to import) and are not allowed to import any libraries.\n' +
+            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 `main`. Do not call the main function. Libraries are installed automatically, do not show how to install them.\n' +
+            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 `main`. Do not call the main function. Libraries are installed automatically, do not show how to install them.\n' +
+            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 `main`. Do not call the main function. Libraries are installed automatically, do not show how to install them.' +
-                PYTHON_RESOURCE_TYPE_SYSTEM +
-                `${allowResourcesFetch ? `\nTo query the available resource types, you can use the \`search_resource_types\` function.` : ''}`);
+            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\` function.` : ''}` +
+                `${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:
@@ -147,6 +235,10 @@ If you want to handle async functions (e.g., using tokio), you need to keep the
             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 '';
     }
@@ -206,19 +298,12 @@ WINDMILL LANGUAGE CONTEXT:
 
 `;
 export const CHAT_USER_DB_CONTEXT = `- {title}: SCHEMA: \n{schema}\n`;
-export function prepareSystemMessage() {
+export function prepareScriptSystemMessage() {
     return {
         role: 'system',
         content: CHAT_SYSTEM_PROMPT
     };
 }
-export const ContextIconMap = {
-    code: Code,
-    error: TriangleAlert,
-    db: Database,
-    diff: Diff,
-    code_piece: Code
-};
 const applyCodePieceToCodeContext = (codePieces, codeContext) => {
     let code = codeContext.split('\n');
     let shiftOffset = 0;
@@ -230,7 +315,17 @@ const applyCodePieceToCodeContext = (codePieces, codeContext) => {
     }
     return code.join('\n');
 };
-export async function prepareUserMessage(instructions, language, selectedContext) {
+export function prepareScriptTools(language, context) {
+    const tools = [];
+    if (['python3', 'php', 'bun', 'deno', 'nativets', 'bunnative'].includes(language)) {
+        tools.push(resourceTypeTool);
+    }
+    if (context.some((c) => c.type === 'db')) {
+        tools.push(dbSchemaTool);
+    }
+    return tools;
+}
+export async function prepareScriptUserMessage(instructions, language, selectedContext, options = {}) {
     let codeContext = 'CODE:\n';
     let errorContext = 'ERROR:\n';
     let dbContext = 'DATABASES:\n';
@@ -263,7 +358,7 @@ export async function prepareUserMessage(instructions, language, selectedContext
             diffContext = diff.length > 3000 ? diff.slice(0, 3000) + '...' : diff;
         }
     }
-    let userMessage = CHAT_USER_PROMPT.replace('{instructions}', instructions).replace('{lang_context}', getLangContext(language, { allowResourcesFetch: true }));
+    let userMessage = CHAT_USER_PROMPT.replace('{instructions}', instructions).replace('{lang_context}', getLangContext(language, { allowResourcesFetch: true, ...options }));
     if (hasCode) {
         userMessage += codeContext;
     }
@@ -276,7 +371,10 @@ export async function prepareUserMessage(instructions, language, selectedContext
     if (hasDiff) {
         userMessage += diffContext;
     }
-    return userMessage;
+    return {
+        role: 'user',
+        content: userMessage
+    };
 }
 const RESOURCE_TYPE_FUNCTION_DEF = {
     type: 'function',
@@ -328,125 +426,38 @@ async function formatDBSchema(dbSchema) {
             stringified);
     }
 }
-async function callTool(functionName, args, lang, workspace) {
-    switch (functionName) {
-        case 'search_resource_types':
-            const formattedResourceTypes = await getFormattedResourceTypes(lang, args.query, workspace);
-            return formattedResourceTypes;
-        case 'get_db_schema':
-            if (!args.resourcePath) {
-                throw new Error('Database path not provided');
-            }
-            const resource = await ResourceService.getResource({
-                workspace: workspace,
-                path: args.resourcePath
-            });
-            const newDbSchemas = {};
-            await getDbSchemas(resource.resource_type, args.resourcePath, workspace, newDbSchemas, (error) => {
-                console.error(error);
-            });
-            dbSchemas.update((schemas) => ({ ...schemas, ...newDbSchemas }));
-            const dbs = get(dbSchemas);
-            const db = dbs[args.resourcePath];
-            if (!db) {
-                throw new Error('Database not found');
-            }
-            const stringSchema = await formatDBSchema(db);
-            return stringSchema;
-        default:
-            throw new Error(`Unknown tool call: ${functionName}`);
+export const resourceTypeTool = {
+    def: RESOURCE_TYPE_FUNCTION_DEF,
+    fn: async ({ args, workspace, helpers, toolCallbacks, toolId }) => {
+        toolCallbacks.setToolStatus(toolId, 'Searching resource types for "' + args.query + '"...');
+        const formattedResourceTypes = await getFormattedResourceTypes(helpers.getLang(), args.query, workspace);
+        toolCallbacks.setToolStatus(toolId, 'Retrieved resource types for "' + args.query + '"');
+        return formattedResourceTypes;
     }
-}
-async function processToolCall(toolCall, messages, lang) {
-    try {
-        const args = JSON.parse(toolCall.function.arguments);
-        let result = '';
-        try {
-            result = await callTool(toolCall.function.name, args, lang, get(workspaceStore) ?? '');
-        }
-        catch (err) {
-            console.error(err);
-            result =
-                'Error while calling tool, MUST tell the user to check the browser console for more details, and then respond as much as possible to the original request';
+};
+export const dbSchemaTool = {
+    def: DB_SCHEMA_FUNCTION_DEF,
+    fn: async ({ args, workspace, toolCallbacks, toolId }) => {
+        if (!args.resourcePath) {
+            throw new Error('Database path not provided');
         }
-        messages.push({
-            role: 'tool',
-            tool_call_id: toolCall.id,
-            content: result
+        toolCallbacks.setToolStatus(toolId, 'Getting database schema for ' + args.resourcePath + '...');
+        const resource = await ResourceService.getResource({
+            workspace: workspace,
+            path: args.resourcePath
         });
-    }
-    catch (err) {
-        console.error(err);
-    }
-}
-export async function chatRequest(messages, abortController, lang, useDbTools, onNewToken) {
-    const toolDefs = [];
-    if (lang === 'python3' ||
-        lang === 'php' ||
-        lang === 'bun' ||
-        lang === 'deno' ||
-        lang === 'nativets' ||
-        lang === 'bunnative') {
-        toolDefs.push(RESOURCE_TYPE_FUNCTION_DEF);
-    }
-    if (useDbTools) {
-        toolDefs.push(DB_SCHEMA_FUNCTION_DEF);
-    }
-    try {
-        let completion = null;
-        while (true) {
-            completion = await getCompletion(messages, abortController, toolDefs);
-            if (completion) {
-                const finalToolCalls = {};
-                for await (const chunk of completion) {
-                    if (!('choices' in chunk && chunk.choices.length > 0 && 'delta' in chunk.choices[0])) {
-                        continue;
-                    }
-                    const c = chunk;
-                    const delta = c.choices[0].delta.content;
-                    if (delta) {
-                        onNewToken(delta);
-                    }
-                    const toolCalls = c.choices[0].delta.tool_calls || [];
-                    for (const toolCall of toolCalls) {
-                        const { index } = toolCall;
-                        const finalToolCall = finalToolCalls[index];
-                        if (!finalToolCall) {
-                            finalToolCalls[index] = toolCall;
-                        }
-                        else {
-                            if (toolCall.function?.arguments) {
-                                if (!finalToolCall.function) {
-                                    finalToolCall.function = toolCall.function;
-                                }
-                                else {
-                                    finalToolCall.function.arguments =
-                                        (finalToolCall.function.arguments ?? '') + toolCall.function.arguments;
-                                }
-                            }
-                        }
-                    }
-                }
-                const toolCalls = Object.values(finalToolCalls).filter((toolCall) => toolCall.id !== undefined && toolCall.function?.arguments !== undefined);
-                if (toolCalls.length > 0) {
-                    messages.push({
-                        role: 'assistant',
-                        tool_calls: toolCalls
-                    });
-                    for (const toolCall of toolCalls) {
-                        await processToolCall(toolCall, messages, lang);
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        return completion;
-    }
-    catch (err) {
-        if (!abortController.signal.aborted) {
-            throw err;
+        const newDbSchemas = {};
+        await getDbSchemas(resource.resource_type, args.resourcePath, workspace, newDbSchemas, (error) => {
+            console.error(error);
+        });
+        dbSchemas.update((schemas) => ({ ...schemas, ...newDbSchemas }));
+        const dbs = get(dbSchemas);
+        const db = dbs[args.resourcePath];
+        if (!db) {
+            throw new Error('Database not found');
         }
+        const stringSchema = await formatDBSchema(db);
+        toolCallbacks.setToolStatus(toolId, 'Retrieved database schema for ' + args.resourcePath);
+        return stringSchema;
     }
-}
+};

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

@@ -0,0 +1,37 @@
+import type { ChatCompletionMessageParam, ChatCompletionMessageToolCall, ChatCompletionTool } from 'openai/resources/chat/completions.mjs';
+import type { ContextElement } from './context';
+import type { ExtendedOpenFlow } from '../../flows/types';
+export type DisplayMessage = {
+    role: 'user' | 'assistant';
+    content: string;
+    contextElements?: ContextElement[];
+    snapshot?: ExtendedOpenFlow;
+} | {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+};
+export declare function processToolCall<T>({ tools, toolCall, messages, helpers, toolCallbacks }: {
+    tools: Tool<T>[];
+    toolCall: ChatCompletionMessageToolCall;
+    messages: ChatCompletionMessageParam[];
+    helpers: T;
+    toolCallbacks: ToolCallbacks;
+}): Promise<void>;
+export interface Tool<T> {
+    def: ChatCompletionTool;
+    fn: (p: {
+        args: any;
+        workspace: string;
+        helpers: T;
+        toolCallbacks: ToolCallbacks;
+        toolId: string;
+    }) => Promise<string>;
+    preAction?: (p: {
+        toolCallbacks: ToolCallbacks;
+        toolId: string;
+    }) => void;
+}
+export interface ToolCallbacks {
+    setToolStatus: (id: string, content: string) => void;
+}

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

@@ -0,0 +1,39 @@
+import { get } from 'svelte/store';
+import { workspaceStore } from '../../../stores';
+async function callTool({ tools, functionName, args, workspace, helpers, toolCallbacks, toolId }) {
+    const tool = tools.find((t) => t.def.function.name === functionName);
+    if (!tool) {
+        throw new Error(`Unknown tool call: ${functionName}`);
+    }
+    return tool.fn({ args, workspace, helpers, toolCallbacks, toolId });
+}
+export async function processToolCall({ tools, toolCall, messages, helpers, toolCallbacks }) {
+    try {
+        const args = JSON.parse(toolCall.function.arguments || '{}');
+        let result = '';
+        try {
+            result = await callTool({
+                tools,
+                functionName: toolCall.function.name,
+                args,
+                workspace: get(workspaceStore) ?? '',
+                helpers,
+                toolCallbacks,
+                toolId: toolCall.id
+            });
+        }
+        catch (err) {
+            console.error(err);
+            result =
+                'Error while calling tool, MUST tell the user to check the browser console for more details, and then respond as much as possible to the original request';
+        }
+        messages.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: result
+        });
+    }
+    catch (err) {
+        console.error(err);
+    }
+}

package/package/components/copilot/chat/sharedChatState.svelte.d.ts

@@ -0,0 +1,11 @@
+export declare const triggerablesByAi: TriggerablesMap;
+export type TriggerablesMap = Record<string, {
+    description: string;
+    onTrigger: ((value?: string) => void) | undefined;
+}>;
+export declare const DEFAULT_SIZE = 22;
+type ChatState = {
+    size: number;
+};
+export declare const chatState: ChatState;
+export {};

package/package/components/copilot/chat/sharedChatState.svelte.js

@@ -0,0 +1,5 @@
+export const triggerablesByAi = $state({});
+export const DEFAULT_SIZE = 22;
+export const chatState = $state({
+    size: localStorage.getItem('ai-chat-open') === 'true' ? DEFAULT_SIZE : 0,
+});

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

@@ -0,0 +1 @@
+export declare function getStringError(result: unknown): string | undefined;

package/package/components/copilot/chat/utils.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+const errorSchema = z.object({
+    error: z.any()
+});
+export function getStringError(result) {
+    try {
+        const parsed = errorSchema.parse(result);
+        if (parsed.error) {
+            return JSON.stringify(parsed.error, null, 2);
+        }
+        else {
+            return undefined;
+        }
+    }
+    catch (_) {
+        return undefined;
+    }
+}