windmill-components 1.448.50 → 1.472.2

package/package/components/copilot/StepInputsGen.svelte

@@ -9,7 +9,7 @@ import { sendUserToast } from '../../toast';
 import Button from '../common/button/Button.svelte';
 import { Check, ExternalLink, Loader2, Wand2 } from 'lucide-svelte';
 import { copilotInfo, stepInputCompletionEnabled } from '../../stores';
-import { Popup } from '../common';
+import Popover from '../meltComponents/Popover.svelte';
 import FlowCopilotInputsModal from './FlowCopilotInputsModal.svelte';
 import { twMerge } from 'tailwind-merge';
 let loading = false;
@@ -189,13 +189,12 @@ let openInputsModal = false;
 			{/if}
 		</Button>
 	{:else}
-		<Popup
+		<Popover
 			floatingConfig={{
 				placement: 'top-end'
 			}}
-			let:close
 		>
-			<svelte:fragment slot="button">
+			<svelte:fragment slot="trigger">
 				<Button
 					size="xs"
 					color="light"
@@ -208,29 +207,33 @@ let openInputsModal = false;
 					Fill inputs
 				</Button>
 			</svelte:fragment>
-			<p class="text-sm">
-				{#if !$copilotInfo.exists_ai_resource}
-					Enable Windmill AI in the{' '}
-					<a
-						href="{base}/workspace_settings?tab=ai"
-						target="_blank"
-						class="inline-flex flex-row items-center gap-1"
-					>
-						workspace settings <ExternalLink size={16} />
-					</a>
-				{:else}
-					Enable step input completion in the{' '}
-					<a
-						href="#user-settings"
-						class="inline-flex flex-row items-center gap-1"
-						on:click={() => {
-							close(null)
-						}}
-					>
-						user settings
-					</a>
-				{/if}
-			</p>
-		</Popup>
+			<svelte:fragment slot="content" let:close>
+				<div class="p-4">
+					<p class="text-sm">
+						{#if !$copilotInfo.exists_ai_resource}
+							Enable Windmill AI in the{' '}
+							<a
+								href="{base}/workspace_settings?tab=ai"
+								target="_blank"
+								class="inline-flex flex-row items-center gap-1"
+							>
+								workspace settings <ExternalLink size={16} />
+							</a>
+						{:else}
+							Enable step input completion in the{' '}
+							<a
+								href="#user-settings"
+								class="inline-flex flex-row items-center gap-1"
+								on:click={() => {
+									close()
+								}}
+							>
+								user settings
+							</a>
+						{/if}
+					</p>
+				</div>
+			</svelte:fragment>
+		</Popover>
 	{/if}
 </div>

package/package/components/copilot/{TestAiKey.svelte → TestAIKey.svelte}

@@ -3,7 +3,9 @@ import Button from '../common/button/Button.svelte';
 import { testKey } from './lib';
 export let disabled = false;
 export let apiKey = undefined;
+export let resourcePath = undefined;
 export let aiProvider;
+export let model;
 let loading = false;
 </script>
 
@@ -20,8 +22,10 @@ let loading = false;
 			setTimeout(() => {
 				abortController.abort()
 			}, 10000)
+
 			await testKey({
 				apiKey,
+				resourcePath,
 				messages: [
 					{
 						role: 'user',
@@ -29,7 +33,8 @@ let loading = false;
 					}
 				],
 				abortController,
-				aiProvider
+				aiProvider,
+				model
 			})
 			sendUserToast('Valid key')
 		} catch (err) {
@@ -41,5 +46,11 @@ let loading = false;
 		} finally {
 			loading = false
 		}
-	}}>Test key</Button
+	}}
 >
+	{#if apiKey}
+		Test key
+	{:else}
+		Test
+	{/if}
+</Button>

package/package/components/copilot/{TestAiKey.svelte.d.ts → TestAIKey.svelte.d.ts}

@@ -1,10 +1,12 @@
 import { SvelteComponent } from "svelte";
-import { type AiProviderTypes } from './lib';
+import type { AIProvider } from '../../gen';
 declare const __propDef: {
     props: {
         disabled?: boolean | undefined;
         apiKey?: string | undefined;
-        aiProvider: AiProviderTypes;
+        resourcePath?: string | undefined;
+        aiProvider: AIProvider;
+        model: string;
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/package/components/copilot/completion.d.ts

@@ -1,2 +1,2 @@
-import { type AiProviderTypes } from './lib';
-export declare function editorCodeCompletion(before: string, after: string, lang: string, abortController: AbortController, aiProvider: AiProviderTypes): Promise<string | undefined>;
+import type { AIProvider } from '../../gen';
+export declare function editorCodeCompletion(before: string, after: string, lang: string, abortController: AbortController, aiProvider: AIProvider): Promise<string | undefined>;

package/package/components/copilot/completion.js

@@ -1,5 +1,5 @@
-import { getNonStreamingCompletion } from './lib';
 import { codeCompletionLoading } from '../../stores';
+import { getNonStreamingCompletion } from './lib';
 const systemPrompt = `You are a code completion assistant, return the code that should go instead of the <completion_tokens>.
 
 - Only return the completion tokens. Do not include the surrounding code.

package/package/components/copilot/flow.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="svelte" />
-import { type FlowModule, type RawScript, type PathScript, type InputTransform } from '../../gen';
-import { type AiProviderTypes } from './lib';
+import { type AIProvider, type FlowModule, type InputTransform, type PathScript, type RawScript } from '../../gen';
 import type { Writable } from 'svelte/store';
 import type Editor from '../Editor.svelte';
 import type { Drawer } from '../common';
@@ -47,10 +46,10 @@ export type FlowCopilotContext = {
 };
 export declare function stepCopilot(module: FlowCopilotModule, deltaCodeStore: Writable<string>, workspace: string, pastModule: (FlowModule & {
     value: RawScript | PathScript;
-}) | undefined, isFirstInLoop: boolean, abortController: AbortController, aiProvider: AiProviderTypes): Promise<string>;
+}) | undefined, isFirstInLoop: boolean, abortController: AbortController, aiProvider: AIProvider): Promise<string>;
 export declare function glueCopilot(inputs: Record<string, InputTransform>, workspace: string, pastModule: FlowModule & {
     value: RawScript | PathScript;
-}, isFirstInLoop: boolean, abortController: AbortController, aiProvider: AiProviderTypes): Promise<{
+}, isFirstInLoop: boolean, abortController: AbortController, aiProvider: AIProvider): Promise<{
     inputs: Record<string, string>;
     allExprs: Record<string, string>;
 }>;

package/package/components/copilot/flow.js

@@ -1,6 +1,6 @@
 import { ScriptService } from '../../gen';
-import { addResourceTypes, deltaCodeCompletion, getNonStreamingCompletion } from './lib';
 import { scriptLangToEditorLang } from '../../scripts';
+import { addResourceTypes, deltaCodeCompletion, getNonStreamingCompletion } from './lib';
 const systemPrompt = `You are a helpful coding assistant for Windmill, a developer platform for running scripts. You write code as instructed by the user. Each user message includes some contextual information which should guide your answer.
 Only output code. Wrap the code in a code block.
 Put explanations directly in the code as comments.

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

@@ -1,65 +1,55 @@
 /// <reference types="svelte" />
-import { OpenAI } from 'openai';
-import { type Script } from '../../gen';
-import type { Writable } from 'svelte/store';
+import type { AIProvider } from '../../gen';
+import { type DBSchema, type GraphqlSchema, type SQLSchema } from '../../stores';
 import { Anthropic } from '@anthropic-ai/sdk';
-import type { DBSchema, GraphqlSchema, SQLSchema } from '../../stores';
 import { Mistral } from '@mistralai/mistralai';
-import type { ChatCompletionCreateParamsStreaming, ChatCompletionMessageParam } from 'openai/resources/index.mjs';
+import { OpenAI } from 'openai';
+import type { ChatCompletionMessageParam } from 'openai/resources/index.mjs';
+import { type Writable } from 'svelte/store';
+import { type Script } from '../../gen';
 import type { MessageCreateParams, MessageParam } from '@anthropic-ai/sdk/resources/messages.mjs';
-import type { ChatCompletionRequest } from '@mistralai/mistralai/models/components/chatcompletionrequest';
-import type { SystemMessage, UserMessage, AssistantMessage, ToolMessage, CompletionEvent, ContentChunk } from '@mistralai/mistralai/models/components';
+import type { CompletionEvent } from '@mistralai/mistralai/models/components';
 export declare const SUPPORTED_LANGUAGES: Set<string>;
-export type AiProviderTypes = 'openai' | 'anthropic' | 'mistral';
-interface AiProvider {
-    init: (workspace: string, updateClient: boolean, token?: string) => void;
-}
-declare class WorkspacedMistral implements AiProvider {
-    private client;
-    init(workspace: string, updateClient: boolean, token?: string): void;
-    getClient(): Mistral;
+export declare const AI_DEFAULT_MODELS: Record<AIProvider, string[]>;
+export declare const OPENAI_COMPATIBLE_BASE_URLS: {
+    readonly groq: "https://api.groq.com/openai/v1";
+    readonly openrouter: "https://openrouter.ai/api/v1";
+    readonly deepseek: "https://api.deepseek.com/v1";
+    readonly googleai: "https://generativelanguage.googleapis.com/v1beta/openai";
+};
+export declare const OPENAI_COMPATIBLE_COMPLETION_CONFIG: {
+    readonly groq: ChatCompletionCreateParamsStreaming;
+    readonly openrouter: ChatCompletionCreateParamsStreaming;
+    readonly deepseek: ChatCompletionCreateParamsStreaming;
+    readonly customai: ChatCompletionCreateParamsStreaming;
+    readonly googleai: ChatCompletionCreateParamsStreaming;
+};
+declare class WorkspacedAIClients {
+    private openaiClient;
+    private anthropicClient;
+    private mistralClient;
+    init(workspace: string): void;
+    private getBaseURL;
+    private initOpenai;
+    private initAnthropic;
+    private initMistral;
+    getOpenaiClient(): OpenAI;
+    getAnthropicClient(): Anthropic;
+    getMistralClient(): Mistral;
 }
-export declare namespace MistralAi {
-    let workspace: WorkspacedMistral;
-    const mistralConfig: ChatCompletionRequest;
-    type MistralParamsMessage = (SystemMessage & {
-        role: 'system';
-    }) | (UserMessage & {
-        role: 'user';
-    }) | (AssistantMessage & {
-        role: 'assistant';
-    }) | (ToolMessage & {
-        role: 'tool';
-    });
-    function retrieveTextValue(chunks: string | ContentChunk[] | null | undefined): string;
-}
-declare class WorkspacedAnthropic implements AiProvider {
-    private client;
-    init(workspace: string, updateClient: boolean, token?: string | undefined): void;
-    getClient(): Anthropic;
-}
-export declare namespace AnthropicAi {
-    let workspace: WorkspacedAnthropic;
+export declare const workspaceAIClients: WorkspacedAIClients;
+export declare namespace AnthropicAI {
     const config: MessageCreateParams;
     function getSystemPromptAndArrayMessages(messages: ChatCompletionMessageParam[]): [string, MessageParam[]];
     function retrieveTextValue(part: Anthropic.Messages.RawMessageStreamEvent): string;
 }
-declare class WorkspacedOpenai implements AiProvider {
-    private client;
-    init(workspace: string, updateClient: boolean, token?: string | undefined): void;
-    getClient(): OpenAI;
-}
-export declare namespace OpenAi {
-    let workspace: WorkspacedOpenai;
-    const openaiConfig: ChatCompletionCreateParamsStreaming;
-    function retrieveTextValue(part: OpenAI.Chat.Completions.ChatCompletionChunk): string;
-}
-export declare function initAllAiWorkspace(workspace: string, updateClient?: boolean): void;
-export declare function testKey({ apiKey, abortController, messages, aiProvider }: {
+export declare function testKey({ apiKey, resourcePath, model, abortController, messages, aiProvider }: {
     apiKey?: string;
+    resourcePath?: string;
+    model: string | undefined;
     messages: ChatCompletionMessageParam[];
     abortController: AbortController;
-    aiProvider: AiProviderTypes;
+    aiProvider: AIProvider;
 }): Promise<void>;
 interface BaseOptions {
     language: Script['language'] | 'frontend' | 'transformer';
@@ -85,9 +75,11 @@ export declare function addResourceTypes(scriptOptions: CopilotOptions, prompt:
 export declare const MAX_SCHEMA_LENGTH: number;
 export declare function addThousandsSeparator(n: number): string;
 export declare function stringifySchema(dbSchema: Omit<SQLSchema, 'stringified'> | Omit<GraphqlSchema, 'stringified'>): string;
-export declare function getNonStreamingCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, aiProvider: AiProviderTypes, model?: any, noCache?: boolean): Promise<string>;
-export declare function getCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, aiProvider: AiProviderTypes, model?: any): Promise<OpenAI.Chat.Completions.ChatCompletion | Anthropic.Messages.Message | import("@mistralai/mistralai/lib/event-streams").EventStream<CompletionEvent>>;
-export declare function getResponseFromEvent(part: Anthropic.Messages.RawMessageStreamEvent | OpenAI.Chat.Completions.ChatCompletionChunk | CompletionEvent, aiProvider: AiProviderTypes): string;
-export declare function copilot(scriptOptions: CopilotOptions, generatedCode: Writable<string>, abortController: AbortController, aiProvider: AiProviderTypes, generatedExplanation?: Writable<string>): Promise<string>;
-export declare function deltaCodeCompletion(messages: ChatCompletionMessageParam[], generatedCodeDelta: Writable<string>, abortController: AbortController, aiProvider: AiProviderTypes): Promise<string>;
+export declare function getNonStreamingCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, aiProvider: AIProvider, apiKey?: string, // testing API KEY directly from the frontend
+resourcePath?: string, // testing resource path passed as a header to the backend proxy
+forceModel?: string): Promise<string>;
+export declare function getCompletion(messages: ChatCompletionMessageParam[], abortController: AbortController, aiProvider: AIProvider): Promise<Anthropic.Messages.Message | OpenAI.Chat.Completions.ChatCompletion | import("@mistralai/mistralai/lib/event-streams").EventStream<CompletionEvent>>;
+export declare function getResponseFromEvent(part: Anthropic.Messages.RawMessageStreamEvent | OpenAI.Chat.Completions.ChatCompletionChunk | CompletionEvent, aiProvider: AIProvider): string;
+export declare function copilot(scriptOptions: CopilotOptions, generatedCode: Writable<string>, abortController: AbortController, aiProvider: AIProvider, generatedExplanation?: Writable<string>): Promise<string>;
+export declare function deltaCodeCompletion(messages: ChatCompletionMessageParam[], generatedCodeDelta: Writable<string>, abortController: AbortController, aiProvider: AIProvider): Promise<string>;
 export {};