windmill-components 1.511.1 → 1.531.0

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

@@ -1,14 +1,15 @@
-import { ResourceService } from '../../../../gen/services.gen';
-import { capitalize, isObject, toCamel } from '../../../../utils';
+import { ResourceService, JobService } from '../../../../gen/services.gen';
+import { capitalize, emptySchema, isObject, toCamel } from '../../../../utils';
 import { get } from 'svelte/store';
 import { compile, phpCompile, pythonCompile } from '../../utils';
 import { copilotSessionModel, 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';
-import { createSearchHubScriptsTool } from '../shared';
+import { createSearchHubScriptsTool, executeTestRun, buildSchemaForTool, buildTestRunArgs } from '../shared';
 import { setupTypeAcquisition } from '../../../../ata';
 import { getModelContextWindow } from '../../lib';
+import { inferArgs } from '../../../../infer';
 // Score threshold for npm packages search filtering
 const SCORE_THRESHOLD = 1000;
 // percentage of the context window for documentation of npm packages
@@ -48,7 +49,6 @@ 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.\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:
@@ -175,9 +175,7 @@ export function getLangContext(lang, { allowResourcesFetch = false, isPreprocess
         : 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;
+                : '')) + TS_WINDMILL_CLIENT_CONTEXT;
     const mainFunctionName = isPreprocessor ? 'preprocessor' : 'main';
     switch (lang) {
         case 'bunnative':
@@ -203,37 +201,36 @@ export function getLangContext(lang, { allowResourcesFetch = false, isPreprocess
                 PHP_RESOURCE_TYPE_SYSTEM +
                 `${allowResourcesFetch ? `\nTo query the available resource types, you can use the \`search_resource_types\` tool.` : ''}` +
                 `\nIf you need to import libraries, you need to specify them as comments in the following manner before the main function:
-\`\`\`
-// require:
-// mylibrary/mylibrary
-// myotherlibrary/myotherlibrary@optionalversion
-\`\`\`
-Make sure to have one per line.
-No need to require autoload, it is already done.`);
+					\`\`\`
+					// require:
+					// mylibrary/mylibrary
+					// myotherlibrary/myotherlibrary@optionalversion
+					\`\`\`
+					Make sure to have one per line.
+					No need to require autoload, it is already done.`);
         case 'rust':
             return `The user is coding in Rust. On Windmill, it is expected the script contains at least one function called \`main\` (without calling it) defined like this:
-\`\`\`rust
-use anyhow::anyhow;
-use serde::Serialize;
-
-#[derive(Serialize, Debug)]
-struct ReturnType {
-    // ...
-}
-
-fn main(...) -> anyhow::Result<ReturnType>
-\`\`\`
-Arguments should be owned. Make sure the return type is serializable.
-
-Packages must be made available with a partial cargo.toml by adding the following comment at the beginning of the script:
-//! \`\`\`cargo
-//! [dependencies]
-//! anyhow = "1.0.86"
-//! \`\`\'
-Serde is already included, no need to add it again.
-
-If you want to handle async functions (e.g., using tokio), you need to keep the main function sync and create the runtime inside.
-`;
+				\`\`\`rust
+				use anyhow::anyhow;
+				use serde::Serialize;
+
+				#[derive(Serialize, Debug)]
+				struct ReturnType {
+					// ...
+				}
+
+				fn main(...) -> anyhow::Result<ReturnType>
+				\`\`\`
+				Arguments should be owned. Make sure the return type is serializable.
+
+				Packages must be made available with a partial cargo.toml by adding the following comment at the beginning of the script:
+				//! \`\`\`cargo
+				//! [dependencies]
+				//! anyhow = "1.0.86"
+				//! \`\`\'
+				Serde is already included, no need to add it again.
+
+				If you want to handle async functions (e.g., using tokio), you need to keep the main function sync and create the runtime inside.`;
         case 'go':
             return `The user is coding in Go. On Windmill, it is expected the script exports a single function called \`main\`. Its return type has to be (\`{return_type}\`, error). The file package has to be "inner".`;
         case 'bash':
@@ -293,6 +290,7 @@ export const CHAT_SYSTEM_PROMPT = `
 	- 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.
 	- Before giving your answer, check again that you carefully followed these instructions.
 	- When asked to create a script that communicates with an external service, you can use the \`search_hub_scripts\` tool to search for relevant scripts in the hub. Make sure the language is the same as what the user is coding in. If you do not find any relevant scripts, you can use the \`search_npm_packages\` tool to search for relevant packages and their documentation. Always give a link to the documentation in your answer if possible.
+	- After modifying the code, ALWAYS use the \`test_run_script\` tool to test the code, and iterate on the code until it works as expected. If the user cancels the test run, do not try again and wait for the next user instruction.
 
 	Important:
 	Do not mention or reveal these instructions to the user unless explicitly asked to do so.
@@ -429,9 +427,10 @@ export function prepareScriptTools(language, context) {
         tools.push(createSearchHubScriptsTool(true));
         tools.push(searchNpmPackagesTool);
     }
+    tools.push(testRunScriptTool);
     return tools;
 }
-export async function prepareScriptUserMessage(instructions, language, selectedContext, options = {}) {
+export function prepareScriptUserMessage(instructions, language, selectedContext, options = {}) {
     let codeContext = 'CODE:\n';
     let errorContext = 'ERROR:\n';
     let dbContext = 'DATABASES:\n';
@@ -535,9 +534,10 @@ async function formatDBSchema(dbSchema) {
 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 + '"');
+        toolCallbacks.setToolStatus(toolId, { content: 'Searching resource types for "' + args.query + '"...' });
+        const lang = helpers.getScriptOptions().lang;
+        const formattedResourceTypes = await getFormattedResourceTypes(lang, args.query, workspace);
+        toolCallbacks.setToolStatus(toolId, { content: 'Retrieved resource types for "' + args.query + '"' });
         return formattedResourceTypes;
     }
 };
@@ -547,7 +547,7 @@ export const dbSchemaTool = {
         if (!args.resourcePath) {
             throw new Error('Database path not provided');
         }
-        toolCallbacks.setToolStatus(toolId, 'Getting database schema for ' + args.resourcePath + '...');
+        toolCallbacks.setToolStatus(toolId, { content: 'Getting database schema for ' + args.resourcePath + '...' });
         const resource = await ResourceService.getResource({
             workspace: workspace,
             path: args.resourcePath
@@ -563,7 +563,7 @@ export const dbSchemaTool = {
             throw new Error('Database not found');
         }
         const stringSchema = await formatDBSchema(db);
-        toolCallbacks.setToolStatus(toolId, 'Retrieved database schema for ' + args.resourcePath);
+        toolCallbacks.setToolStatus(toolId, { content: 'Retrieved database schema for ' + args.resourcePath });
         return stringSchema;
     }
 };
@@ -633,9 +633,9 @@ const SEARCH_NPM_PACKAGES_TOOL = {
 export const searchNpmPackagesTool = {
     def: SEARCH_NPM_PACKAGES_TOOL,
     fn: async ({ args, toolId, toolCallbacks }) => {
-        toolCallbacks.setToolStatus(toolId, 'Searching for relevant packages...');
+        toolCallbacks.setToolStatus(toolId, { content: 'Searching for relevant packages...' });
         const result = await searchExternalIntegrationResources(args);
-        toolCallbacks.setToolStatus(toolId, 'Retrieved relevant packages');
+        toolCallbacks.setToolStatus(toolId, { content: 'Retrieved relevant packages' });
         return result;
     }
 };
@@ -687,3 +687,79 @@ export async function fetchNpmPackageTypes(packageName, version = 'latest') {
         };
     }
 }
+const TEST_RUN_SCRIPT_TOOL = {
+    type: 'function',
+    function: {
+        name: 'test_run_script',
+        description: 'Execute a test run of the current script in the editor',
+        // will be overridden by setSchema
+        parameters: {
+            type: 'object',
+            properties: {
+                args: {
+                    type: 'object',
+                    description: 'Arguments to pass to the script (optional, uses current editor args if not provided)'
+                }
+            },
+            required: []
+        }
+    },
+};
+export const testRunScriptTool = {
+    def: TEST_RUN_SCRIPT_TOOL,
+    fn: async function ({ args, workspace, helpers, toolCallbacks, toolId }) {
+        const scriptOptions = helpers.getScriptOptions();
+        if (!scriptOptions) {
+            toolCallbacks.setToolStatus(toolId, {
+                content: 'No script available to test',
+                error: 'No script found in current context'
+            });
+            throw new Error('No script code available to test. Please ensure you have a script open in the editor.');
+        }
+        let codeToTest = scriptOptions.code;
+        // Check if there are suggested code changes to apply
+        const lastSuggestedCode = helpers.getLastSuggestedCode();
+        if (lastSuggestedCode && lastSuggestedCode !== codeToTest) {
+            codeToTest = lastSuggestedCode;
+            toolCallbacks.setToolStatus(toolId, { content: 'Applying code changes...' });
+            // Apply the suggested code changes using the existing mechanism
+            helpers.applyCode(lastSuggestedCode, true);
+            toolCallbacks.setToolStatus(toolId, { content: 'Code changes applied, starting test...' });
+        }
+        const parsedArgs = await buildTestRunArgs(args, this.def);
+        return executeTestRun({
+            jobStarter: () => JobService.runScriptPreview({
+                workspace: workspace,
+                requestBody: {
+                    path: scriptOptions.path,
+                    content: codeToTest,
+                    args: parsedArgs,
+                    language: scriptOptions.lang,
+                }
+            }),
+            workspace,
+            toolCallbacks,
+            toolId,
+            startMessage: 'Running test...',
+            contextName: 'script'
+        });
+    },
+    setSchema: async function (helpers) {
+        await buildSchemaForTool(this.def, async () => {
+            const scriptOptions = helpers.getScriptOptions();
+            const code = scriptOptions?.code;
+            const lang = scriptOptions?.lang;
+            const lastSuggestedCode = helpers.getLastSuggestedCode();
+            const codeToTest = lastSuggestedCode ?? code;
+            if (codeToTest) {
+                const newSchema = emptySchema();
+                await inferArgs(lang, codeToTest, newSchema);
+                return newSchema;
+            }
+            return emptySchema();
+        });
+    },
+    requiresConfirmation: true,
+    confirmationMessage: 'Run script test',
+    showDetails: true,
+};

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

@@ -1,7 +1,9 @@
 import type { ChatCompletionMessageParam, ChatCompletionMessageToolCall, ChatCompletionTool } from 'openai/resources/chat/completions.mjs';
 import type { ContextElement } from './context';
 import type { ExtendedOpenFlow } from '../../flows/types';
+import type { FunctionParameters } from 'openai/resources/shared.mjs';
 import { z } from 'zod';
+import { type CompletedJob } from '../../../gen';
 type BaseDisplayMessage = {
     content: string;
     contextElements?: ContextElement[];
@@ -16,18 +18,24 @@ export type ToolDisplayMessage = {
     role: 'tool';
     tool_call_id: string;
     content: string;
+    parameters?: any;
+    result?: any;
+    logs?: string;
+    isLoading?: boolean;
+    error?: string;
+    needsConfirmation?: boolean;
+    showDetails?: boolean;
 };
 export type AssistantDisplayMessage = BaseDisplayMessage & {
     role: 'assistant';
 };
 export type DisplayMessage = UserDisplayMessage | ToolDisplayMessage | AssistantDisplayMessage;
-export declare function processToolCall<T>({ tools, toolCall, messages, helpers, toolCallbacks }: {
+export declare function processToolCall<T>({ tools, toolCall, helpers, toolCallbacks }: {
     tools: Tool<T>[];
     toolCall: ChatCompletionMessageToolCall;
-    messages: ChatCompletionMessageParam[];
     helpers: T;
     toolCallbacks: ToolCallbacks;
-}): Promise<void>;
+}): Promise<ChatCompletionMessageParam>;
 export interface Tool<T> {
     def: ChatCompletionTool;
     fn: (p: {
@@ -41,9 +49,14 @@ export interface Tool<T> {
         toolCallbacks: ToolCallbacks;
         toolId: string;
     }) => void;
+    setSchema?: (helpers: any) => Promise<void>;
+    requiresConfirmation?: boolean;
+    confirmationMessage?: string;
+    showDetails?: boolean;
 }
 export interface ToolCallbacks {
-    setToolStatus: (id: string, content: string) => void;
+    setToolStatus: (id: string, metadata?: Partial<ToolDisplayMessage>) => void;
+    requestConfirmation?: (toolId: string) => Promise<boolean>;
 }
 export declare function createToolDef(zodSchema: z.ZodSchema, name: string, description: string): ChatCompletionTool;
 export declare const createSearchHubScriptsTool: (withContent?: boolean) => {
@@ -54,4 +67,18 @@ export declare const createSearchHubScriptsTool: (withContent?: boolean) => {
         toolCallbacks: any;
     }) => Promise<string>;
 };
+export declare function buildSchemaForTool(toolDef: ChatCompletionTool, schemaBuilder: () => Promise<FunctionParameters>): Promise<boolean>;
+export interface TestRunConfig {
+    jobStarter: () => Promise<string>;
+    workspace: string;
+    toolCallbacks: ToolCallbacks;
+    toolId: string;
+    startMessage?: string;
+    contextName: 'script' | 'flow';
+}
+export declare function pollJobCompletion(jobId: string, workspace: string, toolId: string, toolCallbacks: ToolCallbacks): Promise<CompletedJob>;
+export declare function extractCodeFromMarkdown(markdown: string): string[];
+export declare function getLatestAssistantMessage(displayMessages: DisplayMessage[]): string | undefined;
+export declare function buildTestRunArgs(args: any, toolDef: ChatCompletionTool): Promise<any>;
+export declare function executeTestRun(config: TestRunConfig): Promise<string>;
 export {};

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

@@ -1,18 +1,51 @@
 import { get } from 'svelte/store';
-import { workspaceStore } from '../../../stores';
+import { copilotSessionModel, workspaceStore } from '../../../stores';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { z } from 'zod';
-import { ScriptService } from '../../../gen';
+import { ScriptService, JobService } from '../../../gen';
 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}`);
+        throw new Error(`Unknown tool call: ${functionName}. Probably not in the correct mode, use the change_mode tool to switch to the correct mode.`);
     }
     return tool.fn({ args, workspace, helpers, toolCallbacks, toolId });
 }
-export async function processToolCall({ tools, toolCall, messages, helpers, toolCallbacks }) {
+export async function processToolCall({ tools, toolCall, helpers, toolCallbacks }) {
     try {
         const args = JSON.parse(toolCall.function.arguments || '{}');
+        const tool = tools.find((t) => t.def.function.name === toolCall.function.name);
+        // Check if tool requires confirmation
+        const needsConfirmation = tool?.requiresConfirmation;
+        // Add the tool to the display with appropriate status
+        toolCallbacks.setToolStatus(toolCall.id, {
+            ...(tool?.requiresConfirmation ? { content: tool.confirmationMessage ?? "Waiting for confirmation..." } : {}),
+            parameters: args,
+            isLoading: true,
+            needsConfirmation: needsConfirmation,
+            showDetails: tool?.showDetails,
+        });
+        // If confirmation is needed and we have the callback, wait for it
+        if (needsConfirmation && toolCallbacks.requestConfirmation) {
+            const confirmed = await toolCallbacks.requestConfirmation(toolCall.id);
+            if (!confirmed) {
+                toolCallbacks.setToolStatus(toolCall.id, {
+                    content: 'Cancelled by user',
+                    isLoading: false,
+                    error: 'Tool execution was cancelled by user',
+                    needsConfirmation: false
+                });
+                return {
+                    role: 'tool',
+                    tool_call_id: toolCall.id,
+                    content: 'Tool execution was cancelled by user'
+                };
+            }
+            // Update status to executing after confirmation
+            toolCallbacks.setToolStatus(toolCall.id, {
+                isLoading: true,
+                needsConfirmation: false
+            });
+        }
         let result = '';
         try {
             result = await callTool({
@@ -24,20 +57,33 @@ export async function processToolCall({ tools, toolCall, messages, helpers, tool
                 toolCallbacks,
                 toolId: toolCall.id
             });
+            toolCallbacks.setToolStatus(toolCall.id, {
+                isLoading: false
+            });
         }
         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';
+            toolCallbacks.setToolStatus(toolCall.id, {
+                isLoading: false,
+                error: 'An error occurred while calling the tool'
+            });
+            const errorMessage = typeof err === 'string' ? err : 'An error occurred while calling the tool';
+            result = `Error while calling tool: ${errorMessage}`;
         }
-        messages.push({
+        const toAdd = {
             role: 'tool',
             tool_call_id: toolCall.id,
             content: result
-        });
+        };
+        return toAdd;
     }
     catch (err) {
         console.error(err);
+        return {
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: 'Error while calling tool'
+        };
     }
 }
 export function createToolDef(zodSchema, name, description) {
@@ -69,13 +115,17 @@ const searchHubScriptsToolDef = createToolDef(searchHubScriptsSchema, 'search_hu
 export const createSearchHubScriptsTool = (withContent = false) => ({
     def: searchHubScriptsToolDef,
     fn: async ({ args, toolId, toolCallbacks }) => {
-        toolCallbacks.setToolStatus(toolId, 'Searching for hub scripts related to "' + args.query + '"...');
+        toolCallbacks.setToolStatus(toolId, {
+            content: 'Searching for hub scripts related to "' + args.query + '"...'
+        });
         const parsedArgs = searchHubScriptsSchema.parse(args);
         const scripts = await ScriptService.queryHubScripts({
             text: parsedArgs.query,
             kind: 'script'
         });
-        toolCallbacks.setToolStatus(toolId, 'Found ' + scripts.length + ' scripts in the hub related to "' + args.query + '"');
+        toolCallbacks.setToolStatus(toolId, {
+            content: 'Found ' + scripts.length + ' scripts in the hub related to "' + args.query + '"'
+        });
         // if withContent, fetch scripts with their content, limit to 3 results
         const results = await Promise.all(scripts.slice(0, withContent ? 3 : undefined).map(async (s) => {
             let content = '';
@@ -93,3 +143,178 @@ export const createSearchHubScriptsTool = (withContent = false) => ({
         return JSON.stringify(results);
     }
 });
+export async function buildSchemaForTool(toolDef, schemaBuilder) {
+    try {
+        const schema = await schemaBuilder();
+        // if schema properties contains values different from '^[a-zA-Z0-9_.-]{1,64}$'
+        const invalidProperties = Object.keys(schema.properties ?? {}).filter((key) => !/^[a-zA-Z0-9_.-]{1,64}$/.test(key));
+        if (invalidProperties.length > 0) {
+            console.warn(`Invalid flow inputs schema: ${invalidProperties.join(', ')}`);
+            throw new Error(`Invalid flow inputs schema: ${invalidProperties.join(', ')}`);
+        }
+        toolDef.function.parameters = { ...schema, additionalProperties: false };
+        // OPEN AI models don't support strict mode well with schema with complex properties, so we disable it
+        const model = get(copilotSessionModel)?.provider;
+        if (model === 'openai' || model === 'azure_openai') {
+            toolDef.function.strict = false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Error building schema for tool', error);
+        // fallback to schema with args as a JSON string
+        toolDef.function.parameters = { type: 'object', properties: { args: { type: 'string', description: 'JSON string containing the arguments for the tool' } }, additionalProperties: false, strict: false, required: ['args'] };
+        return false;
+    }
+}
+// Constants for result formatting
+const MAX_RESULT_LENGTH = 12000;
+const MAX_LOG_LENGTH = 4000;
+// Common job polling function
+export async function pollJobCompletion(jobId, workspace, toolId, toolCallbacks) {
+    let attempts = 0;
+    const maxAttempts = 60;
+    let job = null;
+    while (attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        attempts++;
+        try {
+            const fetchedJob = await JobService.getJob({
+                workspace: workspace,
+                id: jobId,
+                noLogs: false,
+                noCode: true
+            });
+            if (fetchedJob.type === 'CompletedJob') {
+                job = fetchedJob;
+                break;
+            }
+        }
+        catch (error) {
+            if (attempts >= maxAttempts) {
+                throw error;
+            }
+        }
+    }
+    if (!job) {
+        toolCallbacks.setToolStatus(toolId, {
+            content: 'Test timed out',
+            error: 'Execution timed out or failed to complete'
+        });
+        throw new Error('Test execution timed out after 60 seconds');
+    }
+    return job;
+}
+// Helper function to extract code blocks from markdown text
+export function extractCodeFromMarkdown(markdown) {
+    const codeBlocks = [];
+    // Matches: ```[language]\n[code]\n```
+    const codeBlockRegex = /```(?:[a-z]+)?\n([\s\S]*?)```/g;
+    let match = null;
+    while ((match = codeBlockRegex.exec(markdown)) !== null) {
+        const code = match[1].trim();
+        if (code) {
+            codeBlocks.push(code);
+        }
+    }
+    return codeBlocks;
+}
+// Helper function to get the latest assistant message from display messages
+export function getLatestAssistantMessage(displayMessages) {
+    // Iterate from the end to find the most recent assistant message
+    for (let i = displayMessages.length - 1; i >= 0; i--) {
+        const message = displayMessages[i];
+        if (message.role === 'assistant' && message.content) {
+            return message.content;
+        }
+    }
+    return undefined;
+}
+// Helper function to extract error messages from job results
+function getErrorMessage(result) {
+    if (typeof result === 'object' && result !== null && 'error' in result) {
+        const error = result.error;
+        if (typeof error === 'object' && error !== null && 'message' in error) {
+            const message = error.message;
+            if ('stack' in error) {
+                return (message + '\n' + error.stack);
+            }
+            return message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+    }
+    if (typeof result === 'string') {
+        return result;
+    }
+    return 'Unknown error';
+}
+// Build test run args based on the tool definition, if it contains a fallback schema
+export async function buildTestRunArgs(args, toolDef) {
+    let parsedArgs = args;
+    // if the schema is the fallback schema, parse the args as a JSON string
+    if (toolDef.function.parameters.properties?.args?.description === 'JSON string containing the arguments for the tool') {
+        try {
+            parsedArgs = JSON.parse(args.args);
+        }
+        catch (error) {
+            console.error('Error parsing arguments for tool', error);
+        }
+    }
+    return parsedArgs;
+}
+// Main execution function for test runs
+export async function executeTestRun(config) {
+    try {
+        config.toolCallbacks.setToolStatus(config.toolId, {
+            content: config.startMessage || `Starting ${config.contextName} test...`
+        });
+        const jobId = await config.jobStarter();
+        const contextName = config.contextName.charAt(0).toUpperCase() + config.contextName.slice(1);
+        config.toolCallbacks.setToolStatus(config.toolId, {
+            content: `${contextName} test started, waiting for completion...`
+        });
+        const job = await pollJobCompletion(jobId, config.workspace, config.toolId, config.toolCallbacks);
+        config.toolCallbacks.setToolStatus(config.toolId, {
+            content: `${contextName} test ${job.success ? 'completed successfully' : 'failed'}`,
+            result: formatResult(job.result),
+            logs: formatLogs(job.logs),
+            ...(job.success ? {} : { error: getErrorMessage(job.result) })
+        });
+        return formatResultSummary(job.result, job.logs, job.success);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+        config.toolCallbacks.setToolStatus(config.toolId, {
+            content: `Test execution failed`,
+            error: errorMessage
+        });
+        throw new Error(`Failed to execute test run: ${errorMessage}`);
+    }
+}
+function formatLogs(logs) {
+    if (logs && logs.trim()) {
+        if (logs.length <= MAX_LOG_LENGTH) {
+            return logs;
+        }
+        else {
+            return logs.slice(-MAX_LOG_LENGTH);
+        }
+    }
+    return undefined;
+}
+function formatResult(result) {
+    if (typeof result === 'string') {
+        return result;
+    }
+    return JSON.stringify(result, null, 2);
+}
+function formatResultSummary(result, logs, success) {
+    let resultSummary = '';
+    resultSummary += `Result (${success ? 'SUCCESS' : 'FAILED'})\n\n`;
+    resultSummary += formatResult(result).slice(0, MAX_RESULT_LENGTH);
+    resultSummary += '\n\nLogs:\n\n';
+    resultSummary += formatLogs(logs) ?? 'No logs available';
+    return resultSummary;
+}

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

@@ -18,7 +18,7 @@ export interface ModelResponse {
     };
 }
 export declare function fetchAvailableModels(resourcePath: string, workspace: string, provider: AIProvider): Promise<string[]>;
-export declare function getModelContextWindow(model: string): 1000000 | 128000 | 200000 | 32000;
+export declare function getModelContextWindow(model: string): 1000000 | 128000 | 400000 | 200000 | 32000;
 export declare const PROVIDER_COMPLETION_CONFIG_MAP: Record<AIProvider, ChatCompletionCreateParams>;
 declare class WorkspacedAIClients {
     private openaiClient;