windmill-components 1.558.3 → 1.596.0

package/package/components/copilot/lib.js

@@ -8,6 +8,7 @@ import { EDIT_CONFIG, FIX_CONFIG, GEN_CONFIG } from './prompts';
 import { formatResourceTypes } from './utils';
 import { z } from 'zod';
 import { processToolCall } from './chat/shared';
+import { getNonStreamingOpenAIResponsesCompletion, getOpenAIResponsesCompletionStream } from './chat/openai-responses';
 import { generateRandomString } from '../../utils';
 import { copilotInfo, getCurrentModel } from '../../aiStore';
 export const SUPPORTED_LANGUAGES = new Set(Object.keys(GEN_CONFIG.prompts));
@@ -58,13 +59,70 @@ export const AI_PROVIDERS = {
         label: 'Together AI',
         defaultModels: ['meta-llama/Llama-3.3-70B-Instruct-Turbo']
     },
+    aws_bedrock: {
+        label: 'AWS Bedrock',
+        defaultModels: ['global.anthropic.claude-haiku-4-5-20251001-v1:0']
+    },
     customai: {
         label: 'Custom AI',
         defaultModels: []
     }
 };
 export async function fetchAvailableModels(resourcePath, workspace, provider, signal) {
-    const models = await fetch(`${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy/models`, {
+    // Handle AWS Bedrock separately (needs both foundation-models and inference-profiles)
+    if (provider === 'aws_bedrock') {
+        const headers = {
+            'X-Resource-Path': resourcePath,
+            'X-Provider': provider
+        };
+        // Fetch both foundation models and inference profiles
+        const [foundationModelsResp, inferenceProfilesResp] = await Promise.all([
+            fetch(`${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy/foundation-models`, {
+                signal,
+                headers
+            }),
+            fetch(`${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy/inference-profiles`, {
+                signal,
+                headers
+            })
+        ]);
+        if (!foundationModelsResp.ok) {
+            console.error('Failed to fetch foundation models', foundationModelsResp);
+            throw new Error('Failed to fetch foundation models for AWS Bedrock');
+        }
+        const foundationModelsData = (await foundationModelsResp.json());
+        // Inference profiles fetch might fail in some regions/accounts
+        let inferenceProfiles = [];
+        if (inferenceProfilesResp.ok) {
+            const inferenceProfilesData = (await inferenceProfilesResp.json());
+            inferenceProfiles = inferenceProfilesData.inferenceProfileSummaries || [];
+        }
+        else {
+            console.warn('Failed to fetch inference profiles, will use direct model IDs only');
+        }
+        // Filter to TEXT-capable models
+        const textModels = foundationModelsData.modelSummaries.filter((m) => m.inputModalities?.includes('TEXT') && m.outputModalities?.includes('TEXT'));
+        const onDemandModels = textModels
+            .filter((model) => model.inferenceTypesSupported?.includes('ON_DEMAND') &&
+            !model.inferenceTypesSupported?.includes('INFERENCE_PROFILE'))
+            .map((model) => model.modelId);
+        const inferenceModels = inferenceProfiles.map((profile) => profile.inferenceProfileId);
+        const modelIds = [...onDemandModels, ...inferenceModels];
+        // Sort by default models
+        const defaultModels = AI_PROVIDERS[provider]?.defaultModels || [];
+        return modelIds.sort((a, b) => {
+            const aInDefault = defaultModels.includes(a);
+            const bInDefault = defaultModels.includes(b);
+            if (aInDefault && !bInDefault)
+                return -1;
+            if (!aInDefault && bInDefault)
+                return 1;
+            return 0;
+        });
+    }
+    // Standard provider handling
+    const endpoint = 'models';
+    const models = await fetch(`${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy/${endpoint}`, {
         signal,
         headers: {
             'X-Resource-Path': resourcePath,
@@ -98,8 +156,7 @@ export async function fetchAvailableModels(resourcePath, workspace, provider, si
             case 'azure_openai':
                 return data.data
                     .filter((m) => (m.id.startsWith('gpt-') || m.id.startsWith('o') || m.id.startsWith('codex')) &&
-                    m.lifecycle_status !== 'deprecated' &&
-                    (m.capabilities.completion || m.capabilities.chat_completion))
+                    m.lifecycle_status !== 'deprecated')
                     .map((m) => m.id)
                     .sort(sortFunc(provider));
             case 'googleai':
@@ -111,43 +168,45 @@ export async function fetchAvailableModels(resourcePath, workspace, provider, si
     return data?.data.map((m) => m.id) ?? [];
 }
 export function getModelMaxTokens(provider, model) {
-    if (model.startsWith('gpt-5')) {
+    if (model.includes('gpt-5')) {
         return 128000;
     }
     else if ((provider === 'azure_openai' || provider === 'openai') && model.startsWith('o')) {
         return 100000;
     }
-    else if (model.startsWith('claude-sonnet') || model.startsWith('gemini-2.5')) {
+    else if (model.includes('claude-sonnet') ||
+        model.includes('gemini-2.5') ||
+        model.includes('claude-haiku')) {
         return 64000;
     }
-    else if (model.startsWith('gpt-4.1')) {
+    else if (model.includes('gpt-4.1')) {
         return 32768;
     }
-    else if (model.startsWith('claude-opus')) {
+    else if (model.includes('claude-opus')) {
         return 32000;
     }
-    else if (model.startsWith('gpt-4o') || model.startsWith('codestral')) {
+    else if (model.includes('gpt-4o') || model.includes('codestral')) {
         return 16384;
     }
-    else if (model.startsWith('gpt-4-turbo') || model.startsWith('gpt-3.5')) {
+    else if (model.includes('gpt-4-turbo') || model.includes('gpt-3.5')) {
         return 4096;
     }
     return 8192;
 }
 export function getModelContextWindow(model) {
-    if (model.startsWith('gpt-4.1') || model.startsWith('gemini')) {
+    if (model.includes('gpt-4.1') || model.includes('gemini')) {
         return 1000000;
     }
-    else if (model.startsWith('gpt-5')) {
+    else if (model.includes('gpt-5')) {
         return 400000;
     }
-    else if (model.startsWith('gpt-4o') || model.startsWith('llama-3.3')) {
+    else if (model.includes('gpt-4o') || model.includes('llama-3.3')) {
         return 128000;
     }
-    else if (model.startsWith('claude') || model.startsWith('o4-mini') || model.startsWith('o3')) {
+    else if (model.includes('claude') || model.includes('o4-mini') || model.includes('o3')) {
         return 200000;
     }
-    else if (model.startsWith('codestral')) {
+    else if (model.includes('codestral')) {
         return 32000;
     }
     else {
@@ -231,7 +290,8 @@ export const PROVIDER_COMPLETION_CONFIG_MAP = {
         ...DEFAULT_COMPLETION_CONFIG,
         seed: undefined
     },
-    anthropic: DEFAULT_COMPLETION_CONFIG
+    anthropic: DEFAULT_COMPLETION_CONFIG,
+    aws_bedrock: DEFAULT_COMPLETION_CONFIG
 };
 class WorkspacedAIClients {
     openaiClient;
@@ -433,6 +493,16 @@ export async function getNonStreamingCompletion(messages, abortController, testO
         stream: false,
         forceModelProvider: testOptions?.forceModelProvider
     });
+    // Use Responses API for OpenAI and Azure OpenAI
+    if (provider === 'openai' || provider === 'azure_openai') {
+        try {
+            const response = await getNonStreamingOpenAIResponsesCompletion(messages, abortController, testOptions);
+            return response;
+        }
+        catch (error) {
+            console.error('Error using Responses API:', error);
+        }
+    }
     const fetchOptions = {
         signal: abortController.signal,
         headers: {
@@ -519,8 +589,19 @@ export async function getFimCompletion(prompt, suffix, providerModel, abortContr
         return undefined;
     }
 }
-export async function getCompletion(messages, abortController, tools) {
+export async function getCompletion(messages, abortController, tools, options) {
     const { provider, config } = getProviderAndCompletionConfig({ messages, stream: true, tools });
+    // Use Responses API for OpenAI and Azure OpenAI
+    if ((provider === 'openai' || provider === 'azure_openai') && !options?.forceCompletions) {
+        try {
+            const stream = getOpenAIResponsesCompletionStream(messages, abortController, tools);
+            return stream;
+        }
+        catch (error) {
+            console.error('Error using Responses API:', error);
+        }
+    }
+    // Use Completions API for other providers
     const openaiClient = workspaceAIClients.getOpenaiClient();
     const completion = openaiClient.chat.completions.create(config, {
         signal: abortController.signal,
@@ -540,14 +621,23 @@ function extractFirstJSON(str) {
     }
     return str.slice(0, i + 1);
 }
-export async function parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers) {
+export async function parseOpenAICompletion(completion, callbacks, messages, addedMessages, tools, helpers, _abortController // unused, for signature compatibility with parseAnthropicCompletion
+) {
     const finalToolCalls = {};
+    let malformedFunctionCallError = false;
     let answer = '';
     for await (const chunk of completion) {
         if (!('choices' in chunk && chunk.choices.length > 0 && 'delta' in chunk.choices[0])) {
             continue;
         }
         const c = chunk;
+        // Check for malformed function call error (e.g. from Gemini models)
+        const finishReason = c.choices[0].finish_reason;
+        if (finishReason &&
+            typeof finishReason === 'string' &&
+            finishReason.includes('MALFORMED_FUNCTION_CALL')) {
+            malformedFunctionCallError = true;
+        }
         const delta = c.choices[0].delta.content;
         if (delta) {
             answer += delta;
@@ -596,6 +686,27 @@ export async function parseOpenAICompletion(completion, callbacks, messages, add
                     if (tool && tool.preAction) {
                         tool.preAction({ toolCallbacks: callbacks, toolId: toolCallId });
                     }
+                    const shouldStream = tool?.streamArguments ?? false;
+                    const accumulatedArgs = finalToolCall.function.arguments;
+                    let parameters = undefined;
+                    if (accumulatedArgs) {
+                        try {
+                            parameters = JSON.parse(accumulatedArgs);
+                        }
+                        catch {
+                            parameters = accumulatedArgs;
+                        }
+                    }
+                    // Display tool call with streaming parameters if enabled
+                    callbacks.setToolStatus(toolCallId, {
+                        isLoading: true,
+                        content: `Calling ${funcName}...`,
+                        toolName: funcName,
+                        isStreamingArguments: shouldStream,
+                        showFade: tool?.showFade,
+                        showDetails: tool?.showDetails,
+                        parameters: parameters
+                    });
                 }
             }
         }
@@ -606,6 +717,12 @@ export async function parseOpenAICompletion(completion, callbacks, messages, add
         messages.push(toAdd);
     }
     callbacks.onMessageEnd();
+    // Clear streaming state for all tool calls
+    for (const toolCall of Object.values(finalToolCalls)) {
+        if (toolCall.id) {
+            callbacks.setToolStatus(toolCall.id, { isStreamingArguments: false });
+        }
+    }
     const toolCalls = Object.values(finalToolCalls).filter((toolCall) => toolCall.id !== undefined && toolCall.function?.arguments !== undefined);
     if (toolCalls.length > 0) {
         const toAdd = {
@@ -631,6 +748,41 @@ export async function parseOpenAICompletion(completion, callbacks, messages, add
             addedMessages.push(messageToAdd);
         }
     }
+    else if (malformedFunctionCallError) {
+        // Malformed function call with no tool calls - create artificial tool call to inform AI
+        const fakeToolCallId = generateRandomString();
+        // Show error status to user
+        callbacks.setToolStatus(fakeToolCallId, {
+            isLoading: false,
+            content: 'Malformed function call',
+            error: 'Invalid input given to function call',
+            toolName: 'unknown'
+        });
+        // Add assistant message with fake tool call
+        const assistantMessage = {
+            role: 'assistant',
+            tool_calls: [
+                {
+                    id: fakeToolCallId,
+                    type: 'function',
+                    function: {
+                        name: 'unknown',
+                        arguments: '{}'
+                    }
+                }
+            ]
+        };
+        messages.push(assistantMessage);
+        addedMessages.push(assistantMessage);
+        // Add tool response telling AI to retry
+        const toolResponse = {
+            role: 'tool',
+            tool_call_id: fakeToolCallId,
+            content: 'Invalid input given to function call, MUST TRY WITH SIMPLER ARGUMENTS'
+        };
+        messages.push(toolResponse);
+        addedMessages.push(toolResponse);
+    }
     else {
         return false;
     }
@@ -699,38 +851,3 @@ export async function copilot(scriptOptions, generatedCode, abortController, gen
     }
     return code;
 }
-function getStringEndDelta(prev, now) {
-    return now.slice(prev.length);
-}
-export async function deltaCodeCompletion(messages, generatedCodeDelta, abortController) {
-    const completion = await getCompletion(messages, abortController);
-    let response = '';
-    let code = '';
-    let delta = '';
-    for await (const part of completion) {
-        response += getResponseFromEvent(part);
-        let match = response.match(/```[a-zA-Z]+\n([\s\S]*?)\n```/);
-        if (match) {
-            // if we have a full code block
-            delta = getStringEndDelta(code, match[1]);
-            code = match[1];
-            generatedCodeDelta.set(delta);
-            break;
-        }
-        // partial code block, keep going
-        match = response.match(/```[a-zA-Z]+\n([\s\S]*)/);
-        if (!match) {
-            continue;
-        }
-        if (!match[1].endsWith('`')) {
-            // skip updating if possible that part of three ticks (end of code block)s
-            delta = getStringEndDelta(code, match[1]);
-            generatedCodeDelta.set(delta);
-            code = match[1];
-        }
-    }
-    if (code.length === 0) {
-        throw new Error('No code block found');
-    }
-    return code;
-}

package/package/components/copilot/prompts/edit.yaml

@@ -57,13 +57,13 @@ prompts:
       pub fn main(...) -> Result<ReturnType, Box<dyn std::error::Error>>
       ```
       but do not call it. Favor idiomatic Rust patterns, ensuring safe handling of ownership and borrowing, robust error handling with `Result`, and concurrency if needed (`async`/`tokio` or std threading). 
-      
+
       Follow these guidelines:
       - Include necessary imports and modules only when needed.
       - Add comments explaining important operations and any unsafe usage (if absolutely required).
       - The generated code should be easily executable and testable in an integrated terminal.
       </contextual_information>
-      My instructions: {description}  
+      My instructions: {description}
   go:
     prompt: |-
       Here's my go code: 
@@ -213,6 +213,32 @@ prompts:
       No need to require autoload, it is already done.
       <contextual_information>
       My instructions: {description}
+  csharp:
+    prompt: |-
+      Here's my C# code:
+      ```csharp
+      {code}
+      ```
+      <contextual_information>
+      You have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      My instructions: {description}
+  java:
+    prompt: |-
+      Here's my Java code:
+      ```java
+      {code}
+      ```
+      <contextual_information>
+      You have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      My instructions: {description}
   frontend:
     prompt: |-
       Here's my client-side javascript code: 
@@ -262,3 +288,13 @@ prompts:
       </helpers>
       </contextual_information>
       My instructions: {description}
+  duckdb:
+    prompt: |-
+      Here's my DuckDB code:
+      ```sql
+      {code}
+      ```
+      <contextual_information>
+      Arguments are defined with comments like `-- $age (text) = 20` or `-- $name (text)` (one per row) and used in the statement with $age, $name, etc. To use Ducklake, attach it with `ATTACH 'ducklake' AS dl;` (for main ducklake) or `ATTACH 'ducklake://name' AS dl;` for named ducklakes. To connect to external databases, use `ATTACH '$res:path/to/resource' AS db (TYPE postgres);`. To read S3 files, use `SELECT * FROM read_csv('s3:///path/to/file.csv');` for default storage or `SELECT * FROM read_csv('s3://secondary_storage_name/path/to/file.csv');` for named storage.
+      </contextual_information>
+      My instructions: {description}

package/package/components/copilot/prompts/editPrompt.d.ts

@@ -46,17 +46,20 @@ export declare const EDIT_PROMPT: {
         php: {
             prompt: string;
         };
-        frontend: {
-            prompt: string;
-        };
         csharp: {
             prompt: string;
         };
         java: {
             prompt: string;
         };
+        frontend: {
+            prompt: string;
+        };
         transformer: {
             prompt: string;
         };
+        duckdb: {
+            prompt: string;
+        };
     };
 };

package/package/components/copilot/prompts/editPrompt.js

@@ -8,7 +8,7 @@ export const EDIT_PROMPT = {
             "prompt": "Here's my TypeScript code in a deno running environment:\n```typescript\n{code}\n```\n<contextual_information>\nWe have to export a \"main\" function like this: \"export async function main(...)\" and specify the parameter types but do not call it. You should generally return the result.\nIf needed, the standard fetch method is available globally, do not import it.\nYou can take as parameters resources which are dictionaries containing credentials or configuration information. Name the resource parameters like this: \"{resource_type}Resource\". \nThe resource type name has to be exactly as specified.\n<resourceTypes>\n{resourceTypes}\n</resourceTypes>\nOnly define the type for resources that are actually needed to achieve the function purpose. If the type name conflicts with the imported object, rename the imported object NOT THE TYPE.\nNaming conventions are guidelines, but follow the user's naming choices in the existing code.\n</contextual_information>\nMy instructions: {description}"
         },
         "rust": {
-            "prompt": "Here's my Rust code:\n```rust\n{code}\n```\n<contextual_information>\nPlease define a `main` function in Rust with this signature:\n```rust\npub fn main(...) -> Result<ReturnType, Box<dyn std::error::Error>>\n```\nbut do not call it. Favor idiomatic Rust patterns, ensuring safe handling of ownership and borrowing, robust error handling with `Result`, and concurrency if needed (`async`/`tokio` or std threading). \n\nFollow these guidelines:\n- Include necessary imports and modules only when needed.\n- Add comments explaining important operations and any unsafe usage (if absolutely required).\n- The generated code should be easily executable and testable in an integrated terminal.\n</contextual_information>\nMy instructions: {description}  "
+            "prompt": "Here's my Rust code:\n```rust\n{code}\n```\n<contextual_information>\nPlease define a `main` function in Rust with this signature:\n```rust\npub fn main(...) -> Result<ReturnType, Box<dyn std::error::Error>>\n```\nbut do not call it. Favor idiomatic Rust patterns, ensuring safe handling of ownership and borrowing, robust error handling with `Result`, and concurrency if needed (`async`/`tokio` or std threading). \n\nFollow these guidelines:\n- Include necessary imports and modules only when needed.\n- Add comments explaining important operations and any unsafe usage (if absolutely required).\n- The generated code should be easily executable and testable in an integrated terminal.\n</contextual_information>\nMy instructions: {description}"
         },
         "go": {
             "prompt": "Here's my go code: \n```go\n{code}\n```\n<contextual_information>\nWe have to export a \"main\" function. Import the packages you need. The return type of the function has to be ({return_type}, error). The file package has to be \"inner\"\n</contextual_information>\nMy instructions: {description}"
@@ -46,17 +46,20 @@ export const EDIT_PROMPT = {
         "php": {
             "prompt": "Here's my php code: \n```php\n{code}\n```\n<contextual_information>\nYou have to write a function in php called \"main\". Specify the parameter types. Do not call the main function. You should generally return the result. The script must start with `<?php`.\nYou can take as parameters resources which are classes containing credentials or configuration information. For Windmill to correctly detect the resources to be passed, the resource type name has to be exactly as specified in the following list:\n<resourceTypes>\n{resourceTypes}\n</resourceTypes>\nYou need to define 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.\nBefore defining each type, check if the class already exists using class_exists.\nThe resource type name has to be exactly as specified.\nIf you need to import libraries, you need to specify them as comments in the following manner before the main function:\n```\n// require:\n// mylibrary/mylibrary\n// myotherlibrary/myotherlibrary@optionalversion\n```\nNo need to require autoload, it is already done.\n<contextual_information>\nMy instructions: {description}"
         },
-        "frontend": {
-            "prompt": "Here's my client-side javascript code: \n```javascript\n{code}\n```\n<contextual_information>\nYou can access the context object with the ctx global variable. \nThe app state is a store that can be used to store data. You can access and update the state object with the state global variable like this: state.foo = 'bar'\nYou can use the goto function to navigate to a specific URL: goto(path: string, newTab?: boolean)\nYou can use the openModal and closeModal functions to open and close a modal: openModal(id: string), closeModal(id: string)\nYou can use the setTab function to manually set the tab of a Tab component: setTab(id: string, index: string)\nYou can use the recompute function to recompute a component: recompute(id: string)\nYou can use the getAgGrid function to get the ag-grid instance of a table: getAgGrid(id: string)\nYou can use the setSelectedIndex function to select a row in a table or an AG Grid table: setSelectedIndex(id: string, index: number)\nThe setValue function is meant to set or force the value of a component: setValue(id: string, value: any)\nYou can validate a specific field of a form: validate(id: string, key: string)\nYou can validate all fields of a form: validateAll(id: string, key: string)\nYou can invalidate a specific field of a form: invalidate(id: string, key: string, error: string)\n</contextual_information>\nMy instructions: {description}"
-        },
         "csharp": {
-            "prompt": "Here's my C# code: \n```csharp\n{code}\n```\n<contextual_information>\nYou have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.\nNuGet packages can be added using the format: #r \"nuget: PackageName, Version\" at the top of the script.\nThe Main method signature should be: public static ReturnType Main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nMy instructions: {description}"
+            "prompt": "Here's my C# code:\n```csharp\n{code}\n```\n<contextual_information>\nYou have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.\nNuGet packages can be added using the format: #r \"nuget: PackageName, Version\" at the top of the script.\nThe Main method signature should be: public static ReturnType Main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nMy instructions: {description}"
         },
         "java": {
-            "prompt": "Here's my Java code: \n```java\n{code}\n```\n<contextual_information>\nYou have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.\nDependencies can be added using the format: //requirements://groupId:artifactId:version at the top of the script.\nThe method signature should be: public static Object main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nMy instructions: {description}"
+            "prompt": "Here's my Java code:\n```java\n{code}\n```\n<contextual_information>\nYou have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.\nDependencies can be added using the format: //requirements://groupId:artifactId:version at the top of the script.\nThe method signature should be: public static Object main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nMy instructions: {description}"
+        },
+        "frontend": {
+            "prompt": "Here's my client-side javascript code: \n```javascript\n{code}\n```\n<contextual_information>\nYou can access the context object with the ctx global variable. \nThe app state is a store that can be used to store data. You can access and update the state object with the state global variable like this: state.foo = 'bar'\nYou can use the goto function to navigate to a specific URL: goto(path: string, newTab?: boolean)\nYou can use the openModal and closeModal functions to open and close a modal: openModal(id: string), closeModal(id: string)\nYou can use the setTab function to manually set the tab of a Tab component: setTab(id: string, index: string)\nYou can use the recompute function to recompute a component: recompute(id: string)\nYou can use the getAgGrid function to get the ag-grid instance of a table: getAgGrid(id: string)\nYou can use the setSelectedIndex function to select a row in a table or an AG Grid table: setSelectedIndex(id: string, index: number)\nThe setValue function is meant to set or force the value of a component: setValue(id: string, value: any)\nYou can validate a specific field of a form: validate(id: string, key: string)\nYou can validate all fields of a form: validateAll(id: string, key: string)\nYou can invalidate a specific field of a form: invalidate(id: string, key: string, error: string)\n</contextual_information>\nMy instructions: {description}"
         },
         "transformer": {
             "prompt": "Here's my client-side javascript code: \n```javascript\n{code}\n```\n\n<contextual_information>\nThe code should process the variable `result` according to my instructions.\nThe variable `result` is available globally.\nAt the end of the code, the processed result has to be returned.\n\n<helpers>\nYou can access the context object with the ctx global variable. \nThe app state is a store that can be used to store data. You can access and update the state object with the state global variable like this: state.foo = 'bar'\nYou can use the goto function to navigate to a specific URL: goto(path: string, newTab?: boolean)\nYou can use the openModal and closeModal functions to open and close a modal: openModal(id: string), closeModal(id: string)\nYou can use the setTab function to manually set the tab of a Tab component: setTab(id: string, index: string)\nYou can use the recompute function to recompute a component: recompute(id: string)\nYou can use the getAgGrid function to get the ag-grid instance of a table: getAgGrid(id: string)\nYou can use the setSelectedIndex function to select a row in a table or an AG Grid table: setSelectedIndex(id: string, index: number)\nThe setValue function is meant to set or force the value of a component: setValue(id: string, value: any)\nYou can validate a specific field of a form: validate(id: string, key: string)\nYou can validate all fields of a form: validateAll(id: string, key: string)\nYou can invalidate a specific field of a form: invalidate(id: string, key: string, error: string)\n</helpers>\n</contextual_information>\nMy instructions: {description}"
+        },
+        "duckdb": {
+            "prompt": "Here's my DuckDB code:\n```sql\n{code}\n```\n<contextual_information>\nArguments are defined with comments like `-- $age (text) = 20` or `-- $name (text)` (one per row) and used in the statement with $age, $name, etc. To use Ducklake, attach it with `ATTACH 'ducklake' AS dl;` (for main ducklake) or `ATTACH 'ducklake://name' AS dl;` for named ducklakes. To connect to external databases, use `ATTACH '$res:path/to/resource' AS db (TYPE postgres);`. To read S3 files, use `SELECT * FROM read_csv('s3:///path/to/file.csv');` for default storage or `SELECT * FROM read_csv('s3://secondary_storage_name/path/to/file.csv');` for named storage.\n</contextual_information>\nMy instructions: {description}"
         }
     }
 };

package/package/components/copilot/prompts/fix.yaml

@@ -61,7 +61,7 @@ prompts:
       pub fn main(...) -> Result<ReturnType, Box<dyn std::error::Error>>
       ```
       but do not call it. Favor idiomatic Rust patterns, ensuring safe handling of ownership and borrowing, robust error handling with `Result`, and concurrency if needed (`async`/`tokio` or std threading). 
-      
+
       - Include necessary imports and modules only when needed.
       - Add comments explaining important operations and any unsafe usage (if absolutely required).
       - The generated code should be easily executable and testable in an integrated terminal.
@@ -229,3 +229,42 @@ prompts:
       <contextual_information>
       I get the following error: {error}
       Fix my code.
+  csharp:
+    prompt: |-
+      Here's my C# code:
+      ```csharp
+      {code}
+      ```
+      <contextual_information>
+      You have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      I get the following error: {error}
+      Fix my code.
+  java:
+    prompt: |-
+      Here's my Java code:
+      ```java
+      {code}
+      ```
+      <contextual_information>
+      You have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      I get the following error: {error}
+      Fix my code.
+  duckdb:
+    prompt: |-
+      Here's my DuckDB code:
+      ```sql
+      {code}
+      ```
+      <contextual_information>
+      Arguments are defined with comments like `-- $age (text) = 20` or `-- $name (text)` (one per row) and used in the statement with $age, $name, etc. To use Ducklake, attach it with `ATTACH 'ducklake' AS dl;` (for main ducklake) or `ATTACH 'ducklake://name' AS dl;` for named ducklakes. To connect to external databases, use `ATTACH '$res:path/to/resource' AS db (TYPE postgres);`. To read S3 files, use `SELECT * FROM read_csv('s3:///path/to/file.csv');` for default storage or `SELECT * FROM read_csv('s3://secondary_storage_name/path/to/file.csv');` for named storage.
+      </contextual_information>
+      I get the following error: {error}
+      Fix my code.

package/package/components/copilot/prompts/fixPrompt.d.ts

@@ -52,5 +52,8 @@ export declare const FIX_PROMPT: {
         java: {
             prompt: string;
         };
+        duckdb: {
+            prompt: string;
+        };
     };
 };

package/package/components/copilot/prompts/fixPrompt.js

@@ -47,10 +47,13 @@ export const FIX_PROMPT = {
             "prompt": "Here's my php code: \n```php\n{code}\n```\n<contextual_information>\nYou have to write a function in php called \"main\". Specify the parameter types. Do not call the main function. You should generally return the result. The script must start with `<?php`.\nYou can take as parameters resources which are classes containing credentials or configuration information. For Windmill to correctly detect the resources to be passed, the resource type name has to be exactly as specified in the following list:\n<resourceTypes>\n{resourceTypes}\n</resourceTypes>\nYou need to define 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.\nBefore defining each type, check if the class already exists using class_exists.\nThe resource type name has to be exactly as specified.\nIf you need to import libraries, you need to specify them as comments in the following manner before the main function:\n```\n// require:\n// mylibrary/mylibrary\n// myotherlibrary/myotherlibrary@optionalversion\n```\nNo need to require autoload, it is already done.\n<contextual_information>\nI get the following error: {error}\nFix my code."
         },
         "csharp": {
-            "prompt": "Here's my C# code: \n```csharp\n{code}\n```\n<contextual_information>\nYou have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.\nNuGet packages can be added using the format: #r \"nuget: PackageName, Version\" at the top of the script.\nThe Main method signature should be: public static ReturnType Main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nI get the following error: {error}\nFix my code."
+            "prompt": "Here's my C# code:\n```csharp\n{code}\n```\n<contextual_information>\nYou have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.\nNuGet packages can be added using the format: #r \"nuget: PackageName, Version\" at the top of the script.\nThe Main method signature should be: public static ReturnType Main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nI get the following error: {error}\nFix my code."
         },
         "java": {
-            "prompt": "Here's my Java code: \n```java\n{code}\n```\n<contextual_information>\nYou have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.\nDependencies can be added using the format: //requirements://groupId:artifactId:version at the top of the script.\nThe method signature should be: public static Object main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nI get the following error: {error}\nFix my code."
+            "prompt": "Here's my Java code:\n```java\n{code}\n```\n<contextual_information>\nYou have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.\nDependencies can be added using the format: //requirements://groupId:artifactId:version at the top of the script.\nThe method signature should be: public static Object main(parameter types...)\nArguments are used to generate the input specification and create the frontend UI for the script.\n</contextual_information>\nI get the following error: {error}\nFix my code."
+        },
+        "duckdb": {
+            "prompt": "Here's my DuckDB code:\n```sql\n{code}\n```\n<contextual_information>\nArguments are defined with comments like `-- $age (text) = 20` or `-- $name (text)` (one per row) and used in the statement with $age, $name, etc. To use Ducklake, attach it with `ATTACH 'ducklake' AS dl;` (for main ducklake) or `ATTACH 'ducklake://name' AS dl;` for named ducklakes. To connect to external databases, use `ATTACH '$res:path/to/resource' AS db (TYPE postgres);`. To read S3 files, use `SELECT * FROM read_csv('s3:///path/to/file.csv');` for default storage or `SELECT * FROM read_csv('s3://secondary_storage_name/path/to/file.csv');` for named storage.\n</contextual_information>\nI get the following error: {error}\nFix my code."
         }
     }
 };

package/package/components/copilot/prompts/gen.yaml

@@ -151,6 +151,24 @@ prompts:
       No need to require autoload, it is already done.
       <contextual_information>
       My instructions: {description}
+  csharp:
+    prompt: |-
+      <contextual_information>
+      You have to write C# code with a public static Main method inside a class. The class name is irrelevant. Specify the parameter types. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      My instructions: {description}
+  java:
+    prompt: |-
+      <contextual_information>
+      You have to write Java code with a Main public class and a public static main() method. The return type can be Object or void. Do not call the main function. You should generally return the result.
+      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...)
+      Arguments are used to generate the input specification and create the frontend UI for the script.
+      </contextual_information>
+      My instructions: {description}
   frontend:
     prompt: |-
       Write client-side javascript code that should {description}. 
@@ -176,7 +194,7 @@ prompts:
       At the end of the code, the processed result has to be returned.
 
       <contextual_information>
-      You can access the context object with the ctx global variable. 
+      You can access the context object with the ctx global variable.
       The app state is a store that can be used to store data. You can access and update the state object with the state global variable like this: state.foo = 'bar'
       You can use the goto function to navigate to a specific URL: goto(path: string, newTab?: boolean)
       You can use the openModal and closeModal functions to open and close a modal: openModal(id: string), closeModal(id: string)
@@ -189,3 +207,9 @@ prompts:
       You can validate all fields of a form: validateAll(id: string, key: string)
       You can invalidate a specific field of a form: invalidate(id: string, key: string, error: string)
       </contextual_information>
+  duckdb:
+    prompt: |-
+      <contextual_information>
+      You have to write a statement for DuckDB. Arguments are defined with comments like `-- $age (text) = 20` or `-- $name (text)` (one per row) and used in the statement with $age, $name, etc. To use Ducklake, attach it with `ATTACH 'ducklake' AS dl;` (for main ducklake) or `ATTACH 'ducklake://name' AS dl;` for named ducklakes. To connect to external databases, use `ATTACH '$res:path/to/resource' AS db (TYPE postgres);`. To read S3 files, use `SELECT * FROM read_csv('s3:///path/to/file.csv');` for default storage or `SELECT * FROM read_csv('s3://secondary_storage_name/path/to/file.csv');` for named storage.
+      </contextual_information>
+      My instructions: {description}

package/package/components/copilot/prompts/genPrompt.d.ts

@@ -46,16 +46,19 @@ export declare const GEN_PROMPT: {
         php: {
             prompt: string;
         };
-        frontend: {
+        csharp: {
             prompt: string;
         };
-        transformer: {
+        java: {
             prompt: string;
         };
-        csharp: {
+        frontend: {
             prompt: string;
         };
-        java: {
+        transformer: {
+            prompt: string;
+        };
+        duckdb: {
             prompt: string;
         };
     };