windmill-components 1.448.50 → 1.472.2

package/package/components/copilot/lib.js

@@ -1,29 +1,137 @@
-import { OpenAI } from 'openai';
-import { OpenAPI, ResourceService } from '../../gen';
+import { copilotInfo, copilotSessionModel } from '../../stores';
 import { Anthropic } from '@anthropic-ai/sdk';
-import { formatResourceTypes } from './utils';
-import { EDIT_CONFIG, FIX_CONFIG, GEN_CONFIG } from './prompts';
 import { Mistral } from '@mistralai/mistralai';
 import { buildClientSchema, printSchema } from 'graphql';
+import { OpenAI } from 'openai';
+import { get } from 'svelte/store';
+import { OpenAPI, ResourceService } from '../../gen';
+import { EDIT_CONFIG, FIX_CONFIG, GEN_CONFIG } from './prompts';
+import { formatResourceTypes } from './utils';
 export const SUPPORTED_LANGUAGES = new Set(Object.keys(GEN_CONFIG.prompts));
-class WorkspacedMistral {
-    client;
-    init(workspace, updateClient, token) {
-        if (!this.client || updateClient) {
-            this.client = initWorkspaceAiProvider(workspace, 'mistral', token);
+// need at least one model for each provider except customai
+export const AI_DEFAULT_MODELS = {
+    openai: ['gpt-4o', 'gpt-4o-mini'],
+    anthropic: [
+        'claude-3-7-sonnet-latest',
+        'claude-3-7-sonnet-latest/thinking',
+        'claude-3-5-haiku-latest',
+        'claude-3-5-sonnet-latest'
+    ],
+    mistral: ['codestral-latest'],
+    deepseek: ['deepseek-chat', 'deepseek-reasoner'],
+    googleai: ['gemini-1.5-pro', 'gemini-2.0-flash', 'gemini-1.5-flash'],
+    groq: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant'],
+    openrouter: ['meta-llama/llama-3.2-3b-instruct:free'],
+    customai: []
+};
+export const OPENAI_COMPATIBLE_BASE_URLS = {
+    groq: 'https://api.groq.com/openai/v1',
+    openrouter: 'https://openrouter.ai/api/v1',
+    deepseek: 'https://api.deepseek.com/v1',
+    googleai: 'https://generativelanguage.googleapis.com/v1beta/openai'
+};
+function prepareOpenaiCompatibleMessages(aiProvider, messages) {
+    switch (aiProvider) {
+        case 'googleai':
+            // system messages are not supported by gemini
+            const systemMessage = messages.find((m) => m.role === 'system');
+            if (systemMessage) {
+                messages.shift();
+                const startMessages = [
+                    {
+                        role: 'user',
+                        content: 'System prompt: ' + systemMessage.content
+                    },
+                    {
+                        role: 'assistant',
+                        content: 'Understood'
+                    }
+                ];
+                messages = [...startMessages, ...messages];
+            }
+            return messages;
+        default:
+            return messages;
+    }
+}
+const DEFAULT_COMPLETION_CONFIG = {
+    model: '',
+    max_tokens: 8192,
+    temperature: 0,
+    seed: 42,
+    stream: true,
+    messages: []
+};
+export const OPENAI_COMPATIBLE_COMPLETION_CONFIG = {
+    groq: DEFAULT_COMPLETION_CONFIG,
+    openrouter: DEFAULT_COMPLETION_CONFIG,
+    deepseek: DEFAULT_COMPLETION_CONFIG,
+    customai: DEFAULT_COMPLETION_CONFIG,
+    googleai: {
+        ...DEFAULT_COMPLETION_CONFIG,
+        seed: undefined // not supported by gemini
+    }
+};
+class WorkspacedAIClients {
+    openaiClient;
+    anthropicClient;
+    mistralClient;
+    init(workspace) {
+        this.initOpenai(workspace);
+        this.initAnthropic(workspace);
+        this.initMistral(workspace);
+    }
+    getBaseURL(workspace) {
+        return `${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy`;
+    }
+    initOpenai(workspace) {
+        const baseURL = this.getBaseURL(workspace);
+        this.openaiClient = new OpenAI({
+            baseURL,
+            apiKey: 'fake-key',
+            defaultHeaders: {
+                Authorization: '' // a non empty string will be unable to access Windmill backend proxy
+            },
+            dangerouslyAllowBrowser: true
+        });
+    }
+    initAnthropic(workspace) {
+        const baseURL = this.getBaseURL(workspace);
+        this.anthropicClient = new Anthropic({
+            baseURL,
+            apiKey: 'fake-key',
+            dangerouslyAllowBrowser: true
+        });
+    }
+    initMistral(workspace) {
+        const baseURL = this.getBaseURL(workspace);
+        this.mistralClient = new Mistral({
+            serverURL: baseURL
+        });
+    }
+    getOpenaiClient() {
+        if (!this.openaiClient) {
+            throw new Error('OpenAI not initialized');
         }
+        return this.openaiClient;
     }
-    getClient() {
-        if (!this.client) {
-            throw new Error('AnthropicAi not initialized');
+    getAnthropicClient() {
+        if (!this.anthropicClient) {
+            throw new Error('Anthropic not initialized');
         }
-        return this.client;
+        return this.anthropicClient;
+    }
+    getMistralClient() {
+        if (!this.mistralClient) {
+            throw new Error('Mistral not initialized');
+        }
+        return this.mistralClient;
     }
 }
-export var MistralAi;
-(function (MistralAi) {
-    MistralAi.workspace = new WorkspacedMistral();
-    MistralAi.mistralConfig = {
+export const workspaceAIClients = new WorkspacedAIClients();
+var MistralAI;
+(function (MistralAI) {
+    MistralAI.mistralConfig = {
         temperature: 0,
         model: null,
         maxTokens: 32000,
@@ -41,29 +149,13 @@ export var MistralAi;
         }
         return chunks;
     }
-    MistralAi.retrieveTextValue = retrieveTextValue;
-})(MistralAi || (MistralAi = {}));
-class WorkspacedAnthropic {
-    client;
-    init(workspace, updateClient, token = undefined) {
-        if (!this.client || updateClient) {
-            this.client = initWorkspaceAiProvider(workspace, 'anthropic', token);
-        }
-    }
-    getClient() {
-        if (!this.client) {
-            throw new Error('AnthropicAi not initialized');
-        }
-        return this.client;
-    }
-}
-export var AnthropicAi;
-(function (AnthropicAi) {
-    AnthropicAi.workspace = new WorkspacedAnthropic();
-    AnthropicAi.config = {
-        temperature: 0,
+    MistralAI.retrieveTextValue = retrieveTextValue;
+})(MistralAI || (MistralAI = {}));
+export var AnthropicAI;
+(function (AnthropicAI) {
+    AnthropicAI.config = {
         max_tokens: 8192,
-        model: 'claude-3-5-sonnet-20241022',
+        model: '',
         messages: []
     };
     function getSystemPromptAndArrayMessages(messages) {
@@ -80,42 +172,24 @@ export var AnthropicAi;
         });
         return [system, anthropicMessages ?? []];
     }
-    AnthropicAi.getSystemPromptAndArrayMessages = getSystemPromptAndArrayMessages;
+    AnthropicAI.getSystemPromptAndArrayMessages = getSystemPromptAndArrayMessages;
     function retrieveTextValue(part) {
         let response = '';
         if (part.type == 'content_block_delta') {
             if (part.delta.type == 'text_delta') {
                 response = part.delta.text;
             }
-            else {
-                response = part.delta.partial_json;
-            }
         }
         return response;
     }
-    AnthropicAi.retrieveTextValue = retrieveTextValue;
-})(AnthropicAi || (AnthropicAi = {}));
-class WorkspacedOpenai {
-    client;
-    init(workspace, updateClient, token = undefined) {
-        if (!this.client || updateClient) {
-            this.client = initWorkspaceAiProvider(workspace, 'openai', token);
-        }
-    }
-    getClient() {
-        if (!this.client) {
-            throw new Error('OpenAI not initialized');
-        }
-        return this.client;
-    }
-}
-export var OpenAi;
+    AnthropicAI.retrieveTextValue = retrieveTextValue;
+})(AnthropicAI || (AnthropicAI = {}));
+var OpenAi;
 (function (OpenAi) {
-    OpenAi.workspace = new WorkspacedOpenai();
     OpenAi.openaiConfig = {
         temperature: 0,
         max_tokens: 16384,
-        model: 'gpt-4o-2024-08-06',
+        model: '',
         seed: 42,
         stream: true,
         messages: []
@@ -125,101 +199,15 @@ export var OpenAi;
     }
     OpenAi.retrieveTextValue = retrieveTextValue;
 })(OpenAi || (OpenAi = {}));
-export function initAllAiWorkspace(workspace, updateClient = false) {
-    OpenAi.workspace.init(workspace, updateClient);
-    AnthropicAi.workspace.init(workspace, updateClient);
-    MistralAi.workspace.init(workspace, updateClient);
-}
-function initWorkspaceAiProvider(workspace, aiProvider, token = undefined) {
-    const baseURL = `${location.origin}${OpenAPI.BASE}/w/${workspace}/ai/proxy`;
-    let client;
-    switch (aiProvider) {
-        case 'openai': {
-            client = new OpenAI({
-                baseURL,
-                apiKey: 'fake-key',
-                defaultHeaders: {
-                    Authorization: token ? `Bearer ${token}` : ''
-                },
-                dangerouslyAllowBrowser: true
-            });
-            break;
-        }
-        case 'anthropic': {
-            client = new Anthropic({
-                baseURL,
-                apiKey: 'fake-key',
-                defaultHeaders: {
-                    Authorization: token ? `Bearer ${token}` : ''
-                },
-                dangerouslyAllowBrowser: true
-            });
-            break;
-        }
-        case 'mistral': {
-            client = new Mistral({
-                serverURL: baseURL
-            });
-        }
-    }
-    return client;
-}
-export async function testKey({ apiKey, abortController, messages, aiProvider }) {
-    if (apiKey) {
-        switch (aiProvider) {
-            case 'openai': {
-                const openai = new OpenAI({
-                    apiKey,
-                    dangerouslyAllowBrowser: true
-                });
-                await openai.chat.completions.create({
-                    ...OpenAi.openaiConfig,
-                    messages,
-                    stream: false
-                }, {
-                    signal: abortController.signal
-                });
-                break;
-            }
-            case 'anthropic': {
-                const anthropic = new Anthropic({
-                    apiKey,
-                    dangerouslyAllowBrowser: true
-                });
-                const [, anthropicMessages] = AnthropicAi.getSystemPromptAndArrayMessages(messages);
-                await anthropic.messages.create({
-                    ...AnthropicAi.config,
-                    messages: anthropicMessages,
-                    stream: false
-                }, {
-                    signal: abortController.signal
-                });
-                break;
-            }
-            case 'mistral': {
-                const mistral = new Mistral({
-                    apiKey
-                });
-                await mistral.chat.complete({
-                    ...MistralAi.mistralConfig,
-                    model: 'codestral-latest',
-                    stream: false,
-                    messages: messages
-                }, {
-                    fetchOptions: {
-                        signal: abortController.signal,
-                        headers: {
-                            'content-type': 'application/json'
-                        }
-                    }
-                });
-                break;
-            }
-        }
+export async function testKey({ apiKey, resourcePath, model, abortController, messages, aiProvider }) {
+    if (!apiKey && !resourcePath) {
+        throw new Error('API key or resource path is required');
     }
-    else {
-        await getNonStreamingCompletion(messages, abortController, aiProvider, undefined, true);
+    const modelToTest = model ?? AI_DEFAULT_MODELS[aiProvider][0];
+    if (!modelToTest) {
+        throw new Error('Missing a model to test');
     }
+    await getNonStreamingCompletion(messages, abortController, aiProvider, apiKey, resourcePath, modelToTest);
 }
 async function getResourceTypes(scriptOptions) {
     const elems = scriptOptions.type === 'gen' || scriptOptions.type === 'edit' ? [scriptOptions.description] : [];
@@ -340,111 +328,192 @@ const PROMPTS_CONFIGS = {
     edit: EDIT_CONFIG,
     gen: GEN_CONFIG
 };
-export async function getNonStreamingCompletion(messages, abortController, aiProvider, model = OpenAi.openaiConfig.model, noCache) {
+export async function getNonStreamingCompletion(messages, abortController, aiProvider, apiKey, // testing API KEY directly from the frontend
+resourcePath, // testing resource path passed as a header to the backend proxy
+forceModel) {
     let response = '';
-    const queryOptions = {
-        query: {
-            no_cache: noCache
-        },
+    let model = forceModel;
+    if (!model) {
+        model = get(copilotSessionModel);
+        let info = get(copilotInfo);
+        const { ai_models: aiModels } = info;
+        if (!model || !aiModels.includes(model)) {
+            console.warn('Invalid model, using default model:', aiModels[0]);
+            model = aiModels[0];
+        }
+    }
+    if (!model) {
+        throw new Error('No model found');
+    }
+    const fetchOptions = {
         signal: abortController.signal
     };
+    if (resourcePath) {
+        fetchOptions.headers = {
+            'X-Resource-Path': resourcePath
+        };
+    }
     switch (aiProvider) {
-        case 'openai': {
-            const openaiClient = OpenAi.workspace.getClient();
-            const completion = await openaiClient.chat.completions.create({
-                ...OpenAi.openaiConfig,
-                messages,
-                stream: false,
-                model
-            }, queryOptions);
-            response = completion.choices[0]?.message.content || '';
-            break;
-        }
         case 'anthropic': {
-            const anthropicClient = AnthropicAi.workspace.getClient();
-            const [system, anthropicMessages] = AnthropicAi.getSystemPromptAndArrayMessages(messages);
+            const anthropicClient = apiKey
+                ? new Anthropic({
+                    apiKey,
+                    dangerouslyAllowBrowser: true
+                })
+                : workspaceAIClients.getAnthropicClient();
+            const [system, anthropicMessages] = AnthropicAI.getSystemPromptAndArrayMessages(messages);
             const message = await anthropicClient.messages.create({
-                ...AnthropicAi.config,
+                ...AnthropicAI.config,
                 system,
+                ...(model.endsWith('/thinking')
+                    ? {
+                        thinking: {
+                            type: 'enabled',
+                            budget_tokens: 1024
+                        },
+                        model: model.slice(0, -9)
+                    }
+                    : {
+                        model,
+                        temperature: 0
+                    }),
                 messages: anthropicMessages,
                 stream: false
-            }, queryOptions);
+            }, fetchOptions);
             response = message.content[0].type === 'text' ? message.content[0].text : '';
             break;
         }
         case 'mistral': {
-            const mistralClient = MistralAi.workspace.getClient();
+            const mistralClient = apiKey
+                ? new Mistral({
+                    apiKey
+                })
+                : workspaceAIClients.getMistralClient();
             const message = await mistralClient.chat.complete({
-                ...MistralAi.mistralConfig,
-                model: 'codestral-latest',
+                ...MistralAI.mistralConfig,
+                model,
                 stream: false,
                 messages: messages
             }, {
-                fetchOptions: {
-                    signal: abortController.signal,
-                    cache: 'no-store'
-                }
+                fetchOptions: fetchOptions
             });
-            response = MistralAi.retrieveTextValue(message.choices && message.choices[0].message.content);
+            response = MistralAI.retrieveTextValue(message.choices && message.choices[0].message.content);
             break;
         }
+        default: {
+            if (aiProvider === 'customai' && apiKey) {
+                throw new Error('Cannot test API key for Custom AI, only resource path is supported');
+            }
+            const baseURL = OPENAI_COMPATIBLE_BASE_URLS[aiProvider];
+            if (apiKey && aiProvider !== 'openai' && !baseURL) {
+                throw new Error('No base URL for this provider: ' + aiProvider);
+            }
+            const openaiClient = apiKey
+                ? new OpenAI({
+                    apiKey,
+                    baseURL,
+                    dangerouslyAllowBrowser: true
+                })
+                : workspaceAIClients.getOpenaiClient();
+            const config = aiProvider === 'openai'
+                ? OpenAi.openaiConfig
+                : OPENAI_COMPATIBLE_COMPLETION_CONFIG[aiProvider];
+            if (!config) {
+                throw new Error('No config for this provider: ' + aiProvider);
+            }
+            const processedMessages = prepareOpenaiCompatibleMessages(aiProvider, messages);
+            const completion = await openaiClient.chat.completions.create({
+                ...config,
+                messages: processedMessages,
+                model,
+                stream: false
+            }, fetchOptions);
+            response = completion.choices[0]?.message.content || '';
+        }
     }
     return response;
 }
-export async function getCompletion(messages, abortController, aiProvider, model = OpenAi.openaiConfig.model) {
+export async function getCompletion(messages, abortController, aiProvider) {
+    let model = get(copilotSessionModel);
+    let info = get(copilotInfo);
+    const { ai_models: aiModels } = info;
+    if (!model || !aiModels.includes(model)) {
+        console.warn('Invalid model, using default model:', aiModels[0]);
+        model = aiModels[0];
+    }
+    if (!model) {
+        throw new Error('No model found');
+    }
     switch (aiProvider) {
         case 'anthropic': {
-            const anthropicClient = AnthropicAi.workspace.getClient();
-            const [system, anthropicMessages] = AnthropicAi.getSystemPromptAndArrayMessages(messages);
+            const anthropicClient = workspaceAIClients.getAnthropicClient();
+            const [system, anthropicMessages] = AnthropicAI.getSystemPromptAndArrayMessages(messages);
             const completion = await anthropicClient.messages.create({
-                ...AnthropicAi.config,
+                ...AnthropicAI.config,
+                ...(model.endsWith('/thinking')
+                    ? {
+                        thinking: {
+                            type: 'enabled',
+                            budget_tokens: 1024
+                        },
+                        model: model.slice(0, -9)
+                    }
+                    : {
+                        model,
+                        temperature: 0
+                    }),
                 system,
                 messages: anthropicMessages,
                 stream: true
             }, { signal: abortController.signal });
             return completion;
         }
-        case 'openai': {
-            const openaiClient = OpenAi.workspace.getClient();
-            const completion = await openaiClient.chat.completions.create({
-                ...OpenAi.openaiConfig,
-                messages,
-                model
-            }, {
-                signal: abortController.signal
-            });
-            return completion;
-        }
         case 'mistral': {
-            const mistralClient = MistralAi.workspace.getClient();
+            const mistralClient = workspaceAIClients.getMistralClient();
             const message = await mistralClient.chat.stream({
-                ...MistralAi.mistralConfig,
-                model: 'codestral-latest',
+                ...MistralAI.mistralConfig,
+                model,
                 messages: messages
             }, {
                 fetchOptions: {
-                    signal: abortController.signal,
-                    cache: 'no-store'
+                    signal: abortController.signal
                 }
             });
             return message;
         }
+        default: {
+            const openaiClient = workspaceAIClients.getOpenaiClient();
+            const config = aiProvider === 'openai'
+                ? OpenAi.openaiConfig
+                : OPENAI_COMPATIBLE_COMPLETION_CONFIG[aiProvider];
+            if (!config) {
+                throw new Error('No config for this provider: ' + aiProvider);
+            }
+            const processedMessages = prepareOpenaiCompatibleMessages(aiProvider, messages);
+            const completion = await openaiClient.chat.completions.create({
+                ...config,
+                model,
+                messages: processedMessages
+            }, {
+                signal: abortController.signal
+            });
+            return completion;
+        }
     }
 }
 export function getResponseFromEvent(part, aiProvider) {
     switch (aiProvider) {
-        case 'openai': {
-            const messages = part;
-            return OpenAi.retrieveTextValue(messages);
-        }
         case 'anthropic': {
             const messages = part;
-            return AnthropicAi.retrieveTextValue(messages);
+            return AnthropicAI.retrieveTextValue(messages);
         }
         case 'mistral': {
             const messages = part;
-            return MistralAi.retrieveTextValue(messages.data.choices[0].delta.content);
+            return MistralAI.retrieveTextValue(messages.data.choices[0].delta.content);
         }
+        default:
+            const messages = part;
+            return OpenAi.retrieveTextValue(messages);
     }
 }
 export async function copilot(scriptOptions, generatedCode, abortController, aiProvider, generatedExplanation) {

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

@@ -45,6 +45,25 @@ prompts:
       Naming conventions are guidelines, but follow the user's naming choices in the existing code.
       </contextual_information>
       My instructions: {description}
+  rust:
+    prompt: |-
+      Here's my Rust code:
+      ```rust
+      {code}
+      ```
+      <contextual_information>
+      Please define a `main` function in Rust with this signature:
+      ```rust
+      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}  
   go:
     prompt: |-
       Here's my go code: 

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

@@ -7,6 +7,9 @@ export declare const EDIT_PROMPT: {
         deno: {
             prompt: string;
         };
+        rust: {
+            prompt: string;
+        };
         go: {
             prompt: string;
         };

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

@@ -7,6 +7,9 @@ export const EDIT_PROMPT = {
         "deno": {
             "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}  "
+        },
         "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}"
         },

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

@@ -49,6 +49,25 @@ prompts:
       </contextual_information>
       I get the following error: {error}
       Fix my code.
+  rust:
+    prompt: |-
+      Here's my Rust code:
+      ```rust
+      {code}
+      ```
+      <contextual_information>
+      Please define a `main` function in Rust with this signature:
+      ```rust
+      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.
+      </contextual_information>
+      I get the following error: {error}
+      Fix my code.
   go:
     prompt: |-
       Here's my go code: 

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

@@ -7,6 +7,9 @@ export declare const FIX_PROMPT: {
         deno: {
             prompt: string;
         };
+        rust: {
+            prompt: string;
+        };
         go: {
             prompt: string;
         };