windmill-components 1.504.6 → 1.511.0

package/package/components/copilot/chat/navigator/apiTools.js

@@ -1,5 +1,58 @@
 import { get } from 'svelte/store';
-import { workspaceStore } from '../../../../stores';
+import { workspaceStore, enterpriseLicense } from '../../../../stores';
+/**
+ * Dereferences parameter $ref references in an OpenAPI spec
+ * Only resolves parameter references, not schemas or other components
+ */
+function dereferenceParameters(spec) {
+    if (!spec.components?.parameters) {
+        return spec;
+    }
+    const resolveParameterRef = (paramRef) => {
+        if (paramRef.$ref) {
+            // Extract parameter name from $ref (e.g., "#/components/parameters/WorkspaceId" -> "WorkspaceId")
+            const refPath = paramRef.$ref.split('/');
+            if (refPath.length >= 4 && refPath[1] === 'components' && refPath[2] === 'parameters') {
+                const paramName = refPath[3];
+                const resolvedParam = spec.components?.parameters?.[paramName];
+                if (resolvedParam) {
+                    return resolvedParam;
+                }
+            }
+            console.warn(`Could not resolve parameter reference: ${paramRef.$ref}`);
+            return paramRef;
+        }
+        return paramRef;
+    };
+    const processParameters = (parameters) => {
+        return parameters.map(resolveParameterRef);
+    };
+    const dereferencedSpec = {
+        ...spec,
+        paths: {}
+    };
+    // Process each path
+    for (const [pathKey, pathItem] of Object.entries(spec.paths)) {
+        const newPathItem = { ...pathItem };
+        // Dereference path-level parameters
+        if (pathItem.parameters) {
+            newPathItem.parameters = processParameters(pathItem.parameters);
+        }
+        // Dereference operation-level parameters
+        const methods = ['get', 'post', 'put', 'delete', 'patch', 'options'];
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (operation?.parameters) {
+                newPathItem[method] = {
+                    ...operation,
+                    parameters: processParameters(operation.parameters)
+                };
+            }
+        }
+        dereferencedSpec.paths[pathKey] = newPathItem;
+    }
+    return dereferencedSpec;
+}
 const buildApiCallTools = (name, description, parameters) => {
     return {
         type: 'function',
@@ -46,6 +99,9 @@ export function buildToolsFromOpenApi(openApiSpec, options = {}) {
             const queryParams = (op.parameters || []).filter((p) => p.in === 'query');
             // Add path parameters
             for (const param of pathParams) {
+                if (param.name === 'workspace') {
+                    continue;
+                }
                 parameters.properties[param.name] = {
                     type: param.schema?.type || 'string',
                     description: param.description || `Path parameter: ${param.name}`
@@ -81,9 +137,9 @@ export function buildToolsFromOpenApi(openApiSpec, options = {}) {
                     }
                 }
             }
-            const tool = buildApiCallTools('api_' + op.operationId, op.summary || op.description || `${method.toUpperCase()} ${path}`, parameters);
+            const tool = buildApiCallTools('api_' + op.operationId.replace(/\s+/g, ''), op.summary || op.description || `${method.toUpperCase()} ${path}`, parameters);
             // Store the endpoint path in the map
-            endpointMap['api_' + op.operationId] = `${method.toUpperCase()} ${path}`;
+            endpointMap['api_' + op.operationId.replace(/\s+/g, '')] = `${method.toUpperCase()} ${path}`;
             tools.push(tool);
         }
     }
@@ -97,7 +153,6 @@ export function createApiTools(chatTools, endpointMap = {}) {
                 const toolName = chatTool.function.name;
                 let endpoint = endpointMap[toolName] || '';
                 endpoint = endpoint.replace('{workspace}', get(workspaceStore));
-                toolCallbacks.setToolStatus(toolId, `Calling API endpoint (${endpoint})...`);
                 try {
                     // Extract method and path from endpoint
                     const [method, path] = endpoint.split(' ', 2);
@@ -112,8 +167,8 @@ export function createApiTools(chatTools, endpointMap = {}) {
                         if (key === 'body')
                             continue; // Body is handled separately
                         // Check if this is a path parameter
-                        if (url.includes(`:${key}`)) {
-                            url = url.replace(`:${key}`, encodeURIComponent(String(value)));
+                        if (url.includes(`{${key}}`)) {
+                            url = url.replace(`{${key}}`, encodeURIComponent(String(value)));
                         }
                         else {
                             // Assume it's a query parameter
@@ -130,17 +185,32 @@ export function createApiTools(chatTools, endpointMap = {}) {
                     }
                     // Log the constructed URL
                     console.log(`Calling API: ${method} ${url} with args: ${JSON.stringify(args)}`);
+                    toolCallbacks.setToolStatus(toolId, `Calling API endpoint (${url})...`);
                     const response = await fetch(url, {
                         method: method
                     });
-                    const data = await response.json();
-                    // For now, return a placeholder response
-                    // In a real implementation, we would make the actual API call here
-                    toolCallbacks.setToolStatus(toolId, `API call to ${endpoint} completed`);
-                    return JSON.stringify({
-                        success: true,
-                        data: data
-                    });
+                    if (response.ok) {
+                        let result = '';
+                        if (response.headers.get('content-type')?.includes('application/json')) {
+                            result = await response.json();
+                        }
+                        else {
+                            result = await response.text();
+                        }
+                        toolCallbacks.setToolStatus(toolId, `API call to ${url} completed`);
+                        return JSON.stringify({
+                            success: true,
+                            data: result
+                        });
+                    }
+                    else {
+                        const text = await response.text();
+                        toolCallbacks.setToolStatus(toolId, `API call to ${url} failed`);
+                        return JSON.stringify({
+                            success: false,
+                            data: text
+                        });
+                    }
                 }
                 catch (error) {
                     toolCallbacks.setToolStatus(toolId, `API call to ${endpoint} failed`);
@@ -154,9 +224,12 @@ export function createApiTools(chatTools, endpointMap = {}) {
 export async function loadApiTools() {
     try {
         const response = await fetch('/api/openapi.json');
-        const openApiSpec = (await response.json());
+        const rawOpenApiSpec = (await response.json());
+        // Dereference parameter references
+        const openApiSpec = dereferenceParameters(rawOpenApiSpec);
         const pathsToInclude = [
             'jobs',
+            'jobs_u',
             'scripts',
             'flows',
             'resources',
@@ -164,6 +237,13 @@ export async function loadApiTools() {
             'schedules',
             'workers'
         ];
+        // call srch endpoint to check if it's available
+        if (get(enterpriseLicense)) {
+            const srchResponse = await fetch(`/api/srch/index/search/enabled`);
+            if (srchResponse.ok) {
+                pathsToInclude.push('srch/w'); // job search
+            }
+        }
         const { tools: apiTools, endpointMap } = buildToolsFromOpenApi(openApiSpec, {
             pathFilter: (path) => pathsToInclude.some((p) => path.includes(`/${p}/`)),
             methodFilter: ['get']

package/package/components/copilot/chat/navigator/core.d.ts

@@ -1,6 +1,6 @@
 import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/index.mjs';
 import type { Tool } from '../shared';
-export declare const CHAT_SYSTEM_PROMPT = "\nYou are Windmill's intelligent assistant, designed to help users navigate the application and answer questions about its functionality. It is your only purpose to help the user in the context of the windmill application.\nWindmill is an open-source developer platform for building internal tools, API integrations, background jobs, workflows, and user interfaces. It offers a unified system where scripts are automatically turned into sharable UIs and can be composed into flows or embedded in custom applications.\n\nYou have access to these tools:\n1. View current buttons and inputs on the page (get_triggerable_components)\n2. Execute buttons and inputs (trigger_component) \n3. Get documentation for user requests (get_documentation)\n4. A list of tools to interact with the backend API\n\nINSTRUCTIONS:\n- When users ask about application features or concepts, first use get_documentation internally to retrieve accurate information about how to fulfill the user's request.\n- Then immediately use the available tools to guide the user through the application. Do not wait for the user's confirmation before taking action.\n- If you detect a confirmation modal that needs user confirmation, stop the navigation and let the user know that the action is pending confirmation.\n- Use get_triggerable_components to understand available options, and then trigger the components using trigger_component. Then wait a moment before rescanning the current page, and then continue with the next step. Do this 5 times max.\n- Make sure you navigated as far as possible before responding to the user. Always use get_triggerable_components one last time to make sure you didn't miss anything.\n- If you are not able to fulfill the user's request after 5 attempts, redirect the user to the documentation.\n- If you are asked to fill a form or act on an input, input the existing json object and change the fields the user asked you to change. Take into account the prompt_for_ai field of the schema to know what and how to do changes. Then tell the user that you have updated the form, and ask him to review the changes before running the script or flow.\n- For form inputs where format starts with \"resource-\" and is not \"resource-obj\", fetch the available resources using get_available_resources, and then use the resource_path prefixed with \"$res:\" to fill the input.\n- If you are not sure about an input, set the ones you are sure about, and then ask the user for the value of the input you are not sure about.\n\nGENERAL PRINCIPLES:\n- Be concise but thorough\n- Focus on taking action and completing the user's goals\n- Maintain a friendly, professional tone\n- If you encounter an error or can't complete a request, explain why and suggest alternatives\n- When asked about a specific script, flow or app, first check components directly related to the mentioned entity, before checking the other components.\n- When you do not find what you are looking for on the current page, go to the home page by looking for the \"Home\" component, then scan the components again.\n\nIMPORTANT CONSIDERATIONS:\n- If you do an API call, make sure you ask the user if he also wants you to navigate the application to fulfill his request.\n- The user might have changed the page in the middle of the conversation, so make sure you rescan the page on each user request instead of just responding that you cannot find what the user is asking for.\n- If you navigate to a script creation page, consider this:\n  - The page opens with the settings drawer open. After doing the changes mentioned by the user, close the settings drawer.\n  - Then if the user has described what he wanted the script to do, switch to script mode with the change_mode tool, and use the new tools you'll have access to to edit the script.\n- If you navigate to a flow creation page, consider this:\n  - If the user has described what he wanted the flow to do, switch to flow mode with the change_mode tool before using the new tools you'll have access to to edit the flow.\n\nAPI_TOOLS_RESTRICTIONS:\n- You can only use the API tools to fetch data from the backend API after you tried to navigate the application to fulfill the user's request and it's not enough to do so. ALWAYS ask the user if he also wants you to navigate the application to fulfill his request.\n- If you use api tools, also fetch the relevant documentation to help the user understand the data you fetched, with a link to the documentation if possible.\n\nRETRIEVE_AVAILABLE_RESOURCES_RESTRICTION:\n- You can only use the get_available_resources tool to fill a form or an input based on the user's request. Do not use it when directly asked to fetch available resources, use the API tools instead.\n\nAlways use the provided tools purposefully and appropriately to achieve the user's goals.\nYour actions only allow you to navigate the application through the provided tools.\nWhen you complete the user's request, do not say \"I created...\" or \"I updated...\" or \"I deleted...\", but rather complete your response with precisions about how it works based on the documentation. Also drop a link to the relevant documentation if possible.\n\nExample of good behavior:\n- User: \"How can I set my AI providers?\"\n- You: <call get_documentation and fetch relevant documentation>\n- You: <call get_triggerable_components to find relevant components>\n- You: <trigger the components>\n- You: \"<precisions about the request based on the documentation>\"\n";
+export declare const CHAT_SYSTEM_PROMPT: string;
 export declare const getDocumentationTool: Tool<{}>;
 export declare const navigatorTools: Tool<{}>[];
 export declare function prepareNavigatorSystemMessage(): ChatCompletionSystemMessageParam;

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

@@ -1,5 +1,5 @@
 import { ResourceService } from '../../../../gen';
-import { workspaceStore } from '../../../../stores';
+import { enterpriseLicense, workspaceStore } from '../../../../stores';
 import { get } from 'svelte/store';
 import { triggerablesByAi } from '../sharedChatState.svelte';
 export const CHAT_SYSTEM_PROMPT = `
@@ -22,6 +22,7 @@ INSTRUCTIONS:
 - If you are asked to fill a form or act on an input, input the existing json object and change the fields the user asked you to change. Take into account the prompt_for_ai field of the schema to know what and how to do changes. Then tell the user that you have updated the form, and ask him to review the changes before running the script or flow.
 - For form inputs where format starts with "resource-" and is not "resource-obj", fetch the available resources using get_available_resources, and then use the resource_path prefixed with "$res:" to fill the input.
 - If you are not sure about an input, set the ones you are sure about, and then ask the user for the value of the input you are not sure about.
+${get(enterpriseLicense) ? `- If asked to look through the jobs logs, use the /srch/w/{workspace}/index/search/job endpoint to search for the relevant jobs runs. Then use /w/{workspace}/jobs_u/get to get the logs of each job.` : ''}
 
 GENERAL PRINCIPLES:
 - Be concise but thorough

package/package/components/copilot/chat/script/core.d.ts

@@ -1,7 +1,7 @@
 import type { ResourceType, ScriptLang } from '../../../../gen/types.gen';
 import type { ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam } from 'openai/resources/index.mjs';
 import type { ContextElement } from '../context';
-import type { Tool } from '../shared';
+import { type Tool } from '../shared';
 export declare function formatResourceTypes(allResourceTypes: ResourceType[], lang: 'python3' | 'php' | 'bun' | 'deno' | 'nativets' | 'bunnative'): string;
 export declare const SUPPORTED_CHAT_SCRIPT_LANGUAGES: string[];
 export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' | 'tsx' | 'json', { allowResourcesFetch, isPreprocessor }?: {
@@ -10,7 +10,7 @@ export declare function getLangContext(lang: ScriptLang | 'bunnative' | 'jsx' |
     isFailure?: boolean;
 }): string;
 export declare function getFormattedResourceTypes(lang: ScriptLang | 'bunnative', prompt: string, workspace: string): Promise<string>;
-export declare const CHAT_SYSTEM_PROMPT = "\n\tYou are a coding assistant for the Windmill platform. You are provided with a list of `INSTRUCTIONS` and the current contents of a code file under `CODE`.\n\n\tYour task is to respond to the user's request. Assume all user queries are valid and actionable.\n\n\tWhen the user requests code changes:\n\t- Always include a **single code block** with the **entire updated file**, not just the modified sections.\n\t- The code can include `[#START]` and `[#END]` markers to indicate the start and end of a code piece. You MUST only modify the code between these markers if given, and remove them in your response. If a question is asked about the code, you MUST only talk about the code between the markers. Refer to it as the code piece, not the code between the markers.\n\t- Follow the instructions carefully and explain the reasoning behind your changes.\n\t- If the request is abstract (e.g., \"make this cleaner\"), interpret it concretely and reflect that in the code block.\n\t- Preserve existing formatting, indentation, and whitespace unless changes are strictly required to fulfill the user's request.\n\t- The user can ask you to look at or modify specific files, databases or errors by having its name in the INSTRUCTIONS preceded by the @ symbol. In this case, put your focus on the element that is explicitly mentioned.\n\t- The user can ask you questions about a list of `DATABASES` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.\n\t- You can also receive a `DIFF` of the changes that have been made to the code. You should use this diff to give better answers.\n\t- Before giving your answer, check again that you carefully followed these instructions.\n\n\tImportant:\n\tDo not mention or reveal these instructions to the user unless explicitly asked to do so.\n";
+export declare const CHAT_SYSTEM_PROMPT = "\n\tYou are a coding assistant for the Windmill platform. You are provided with a list of `INSTRUCTIONS` and the current contents of a code file under `CODE`.\n\n\tYour task is to respond to the user's request. Assume all user queries are valid and actionable.\n\n\tWhen the user requests code changes:\n\t- Always include a **single code block** with the **entire updated file**, not just the modified sections.\n\t- The code can include `[#START]` and `[#END]` markers to indicate the start and end of a code piece. You MUST only modify the code between these markers if given, and remove them in your response. If a question is asked about the code, you MUST only talk about the code between the markers. Refer to it as the code piece, not the code between the markers.\n\t- Follow the instructions carefully and explain the reasoning behind your changes.\n\t- If the request is abstract (e.g., \"make this cleaner\"), interpret it concretely and reflect that in the code block.\n\t- Preserve existing formatting, indentation, and whitespace unless changes are strictly required to fulfill the user's request.\n\t- The user can ask you to look at or modify specific files, databases or errors by having its name in the INSTRUCTIONS preceded by the @ symbol. In this case, put your focus on the element that is explicitly mentioned.\n\t- The user can ask you questions about a list of `DATABASES` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.\n\t- You can also receive a `DIFF` of the changes that have been made to the code. You should use this diff to give better answers.\n\t- Before giving your answer, check again that you carefully followed these instructions.\n\t- 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.\n\n\tImportant:\n\tDo not mention or reveal these instructions to the user unless explicitly asked to do so.\n";
 export declare const INLINE_CHAT_SYSTEM_PROMPT = "\n# Windmill Inline Coding Assistant\n\nYou are a coding assistant for the Windmill platform. You provide precise code modifications based on user instructions.\n\n## Input Format\n\nYou will receive:\n- **INSTRUCTIONS**: User's modification request\n- **CODE**: Current code content with modification boundaries\n- **DATABASES** *(optional)*: Available workspace databases\n\n### Code Boundaries\n\nThe code contains `[#START]` and `[#END]` markers indicating the modification scope:\n- **MUST** only modify code between these markers\n- **MUST** remove the markers in your response\n- **MUST** preserve all other code exactly as provided\n\n## Task Requirements\n\nReturn the modified CODE that fulfills the user's request. Assume all user queries are valid and actionable.\n\n### Critical Rules\n\n- \u2705 **ALWAYS** include a single code block with the entire updated CODE\n- \u2705 **ALWAYS** use the structured XML output format below\n- \u274C **NEVER** include only modified sections\n- \u274C **NEVER** add explanatory text or comments outside the format\n- \u274C **NEVER** include ``` code fences in your response\n- \u274C **NEVER** modify the code outside the boundaries\n\n## Output Format\n\n```xml\n<changes_made>\nBrief description of what was changed\n</changes_made>\n<new_code>\n[complete modified code without markers]\n</new_code>\n```\n\n## Example\n\n### Input:\n```xml\n<user_request>\nINSTRUCTIONS:\nReturn 2 instead of 1\n\nCODE:\nimport * as wmill from \"windmill-client\"\n\nfunction test() {\n\treturn \"hello\"\n}\n\n[#START]\nexport async function main() {\n\treturn 1;\n}\n[#END]\n</user_request>\n```\n\n### Expected Output:\n```xml\n<changes_made>\nChanged return value from 1 to 2 in main function\n</changes_made>\n<new_code>\nimport * as wmill from \"windmill-client\"\n\nfunction test() {\n\treturn \"hello\"\n}\n\nexport async function main() {\n\treturn 2;\n}\n</new_code>\n```\n";
 export declare const CHAT_USER_PROMPT = "\nINSTRUCTIONS:\n{instructions}\n\nWINDMILL LANGUAGE CONTEXT:\n{lang_context}\n\n";
 export declare const CHAT_USER_DB_CONTEXT = "- {title}: SCHEMA: \n{schema}\n";
@@ -25,3 +25,12 @@ export interface ScriptChatHelpers {
 }
 export declare const resourceTypeTool: Tool<ScriptChatHelpers>;
 export declare const dbSchemaTool: Tool<ScriptChatHelpers>;
+export declare function searchExternalIntegrationResources(args: {
+    query: string;
+}): Promise<string>;
+export declare const searchNpmPackagesTool: Tool<ScriptChatHelpers>;
+export declare function fetchNpmPackageTypes(packageName: string, version?: string): Promise<{
+    success: boolean;
+    types: string;
+    error?: string;
+}>;

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

@@ -2,10 +2,19 @@ import { ResourceService } from '../../../../gen/services.gen';
 import { capitalize, isObject, toCamel } from '../../../../utils';
 import { get } from 'svelte/store';
 import { compile, phpCompile, pythonCompile } from '../../utils';
-import { dbSchemas } from '../../../../stores';
+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 { setupTypeAcquisition } from '../../../../ata';
+import { getModelContextWindow } from '../../lib';
+// Score threshold for npm packages search filtering
+const SCORE_THRESHOLD = 1000;
+// percentage of the context window for documentation of npm packages
+const DOCS_CONTEXT_PERCENTAGE = 1;
+// percentage of the context window for types of npm packages
+const TYPES_CONTEXT_PERCENTAGE = 1;
 export function formatResourceTypes(allResourceTypes, lang) {
     const resourceTypes = allResourceTypes.filter((rt) => isObject(rt.schema) && 'properties' in rt.schema && isObject(rt.schema.properties));
     if (lang === 'python3') {
@@ -45,8 +54,8 @@ const TS_WINDMILL_CLIENT_CONTEXT = `
 The windmill client (wmill) can be used to interact with Windmill from the script. Import it with \`import * as wmill from "windmill-client"\`. Key functions include:
 
 // Resource operations
-wmill.getResource(path?: string): Promise<any> // Get resource value by path
-wmill.setResource(value: any, path?: string): Promise<void> // Set resource value
+wmill.getResource(path?: string, undefinedIfEmpty?: boolean): Promise<any> // Get resource value by path
+wmill.setResource(value: any, path?: string, initializeToTypeIfNotExist?: string): Promise<void> // Set resource value
 
 // State management (persistent across executions)  
 wmill.getState(): Promise<any> // Get shared state
@@ -54,36 +63,39 @@ wmill.setState(state: any): Promise<void> // Set shared state
 
 // Variables
 wmill.getVariable(path: string): Promise<string> // Get variable value
-wmill.setVariable(path: string, value: string): Promise<void> // Set variable value
+wmill.setVariable(path: string, value: string, isSecretIfNotExist?: boolean, descriptionIfNotExist?: string): Promise<void> // Set variable value
 
 // Script execution
-wmill.runScript(path: string, args?: Record<string, any>): Promise<any> // Run script synchronously
-wmill.runScriptAsync(path: string, args?: Record<string, any>): Promise<string> // Run script async, returns job ID
-wmill.waitJob(jobId: string): Promise<any> // Wait for job completion and get result
+wmill.runScript(path?: string | null, hash_?: string | null, args?: Record<string, any> | null, verbose?: boolean): Promise<any> // Run script synchronously
+wmill.runScriptAsync(path: string | null, hash_: string | null, args: Record<string, any> | null, scheduledInSeconds?: number | null): Promise<string> // Run script async, returns job ID
+wmill.waitJob(jobId: string, verbose?: boolean): Promise<any> // Wait for job completion and get result
+wmill.getResult(jobId: string): Promise<any> // Get job result by ID
+wmill.getResultMaybe(jobId: string): Promise<any> // Get job result by ID, returns undefined if not found
+wmill.getRootJobId(jobId?: string): Promise<string> // Get root job ID from job ID
 
 // S3 file operations (if S3 is configured)
-wmill.loadS3File(s3object: S3Object | string): Promise<Uint8Array> // Load file content from S3
-wmill.writeS3File(s3object: S3Object | string, content: string | Blob): Promise<S3Object> // Write file to S3
+wmill.loadS3File(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Uint8Array | undefined> // Load file content from S3
+wmill.loadS3FileStream(s3object: S3Object, s3ResourcePath?: string | undefined): Promise<Blob | undefined> // Load file content from S3 as stream
+wmill.writeS3File(s3object: S3Object | undefined, fileContent: string | Blob, s3ResourcePath?: string | undefined): Promise<S3Object> // Write file to S3
 
 // Flow operations
-wmill.setFlowUserState(key: string, value: any): Promise<void> // Set flow user state
-wmill.getFlowUserState(key: string): Promise<any> // Get flow user state
-wmill.getResumeUrls(): Promise<{approvalPage: string, resume: string, cancel: string}> // Get approval URLs
+wmill.setFlowUserState(key: string, value: any, errorIfNotPossible?: boolean): Promise<void> // Set flow user state
+wmill.getFlowUserState(key: string, errorIfNotPossible?: boolean): Promise<any> // Get flow user state
+wmill.getResumeUrls(approver?: string): Promise<{approvalPage: string, resume: string, cancel: string}> // Get approval URLs
 
-// Utilities
-wmill.getWorkspace(): string // Get current workspace
-wmill.databaseUrlFromResource(path: string): Promise<string> // Get database URL from resource`;
+`;
 const PYTHON_WINDMILL_CLIENT_CONTEXT = `
 
 The windmill client (wmill) can be used to interact with Windmill from the script. Import it with \`import wmill\`. Key functions include:
 
 // Resource operations
-wmill.get_resource(path: str) -> dict | None  // Get resource value by path
+wmill.get_resource(path: str, none_if_undefined: bool = False) -> dict | None  // Get resource value by path
 wmill.set_resource(path: str, value: Any, resource_type: str = "any") -> None  // Set resource value
 
 // State management (persistent across executions)
 wmill.get_state() -> Any  // Get shared state (deprecated, use flow user state)
 wmill.set_state(value: Any) -> None  // Set shared state
+wmill.get_state_path() -> str  // Get state path
 wmill.get_flow_user_state(key: str) -> Any  // Get flow user state 
 wmill.set_flow_user_state(key: str, value: Any) -> None  // Set flow user state
 
@@ -92,22 +104,27 @@ wmill.get_variable(path: str) -> str  // Get variable value
 wmill.set_variable(path: str, value: str, is_secret: bool = False) -> None  // Set variable value
 
 // Script execution
-wmill.run_script(path: str, args: dict = None, timeout = None) -> Any  // Run script synchronously
-wmill.run_script_async(path: str, args: dict = None, scheduled_in_secs: int = None) -> str  // Run script async, returns job ID
-wmill.wait_job(job_id: str, timeout = None) -> Any  // Wait for job completion and get result
+wmill.run_script(path: str = None, hash_: str = None, args: dict = None, timeout = None, verbose: bool = False, cleanup: bool = True, assert_result_is_not_none: bool = True) -> Any  // Run script synchronously
+wmill.run_script_async(path: str = None, hash_: str = None, args: dict = None, scheduled_in_secs: int = None) -> str  // Run script async, returns job ID
+wmill.wait_job(job_id: str, timeout = None, verbose: bool = False, cleanup: bool = True, assert_result_is_not_none: bool = False) -> Any  // Wait for job completion and get result
+wmill.get_result(job_id: str, assert_result_is_not_none: bool = True) -> Any  // Get job result by ID
+wmill.get_root_job_id(job_id: str | None = None) -> str  // Get root job ID from job ID
 
 // S3 file operations (if S3 is configured)
-wmill.load_s3_file(s3object: S3Object | str, s3_resource_path: str = None) -> bytes  // Load file content from S3
-wmill.write_s3_file(s3object: S3Object | str, file_content: bytes, s3_resource_path: str = None) -> S3Object  // Write file to S3
+wmill.load_s3_file(s3object: S3Object | str, s3_resource_path: str | None = None) -> bytes  // Load file content from S3
+wmill.load_s3_file_reader(s3object: S3Object | str, s3_resource_path: str | None = None) -> BufferedReader  // Load S3 file as stream reader
+wmill.write_s3_file(s3object: S3Object | str | None, file_content: BufferedReader | bytes, s3_resource_path: str | None = None, content_type: str | None = None, content_disposition: str | None = None) -> S3Object  // Write file to S3
 
 // Flow operations  
-wmill.run_flow_async(path: str, args: dict = None) -> str  // Run flow asynchronously
+wmill.run_flow_async(path: str, args: dict = None, scheduled_in_secs: int = None, do_not_track_in_parent: bool = True) -> str  // Run flow asynchronously
 wmill.get_resume_urls(approver: str = None) -> dict  // Get approval URLs for flow steps
 
 // Utilities
+wmill.get_workspace() -> str  // Get current workspace
 wmill.whoami() -> dict  // Get current user information
 wmill.get_job_status(job_id: str) -> str  // Get job status ("RUNNING" | "WAITING" | "COMPLETED")
-wmill.set_progress(value: int) -> None  // Set job progress (0-100)`;
+wmill.set_progress(value: int, job_id: Optional[str] = None) -> None  // Set job progress (0-100)
+wmill.get_progress(job_id: Optional[str] = None) -> Any  // Get job progress`;
 const PYTHON_RESOURCE_TYPE_SYSTEM = `On Windmill, credentials and configuration are stored in resources and passed as parameters to main.
 If you need credentials, you should add a parameter to \`main\` with the corresponding resource type.
 You need to **redefine** the type of the resources that are needed before the main function as TypedDict, but only include them if they are actually needed to achieve the function purpose.
@@ -275,6 +292,7 @@ export const CHAT_SYSTEM_PROMPT = `
 	- The user can ask you questions about a list of \`DATABASES\` that are available in the user's workspace. If the user asks you a question about a database, you should ask the user to specify the database name if not given, or take the only one available if there is only one.
 	- 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.
 
 	Important:
 	Do not mention or reveal these instructions to the user unless explicitly asked to do so.
@@ -407,6 +425,10 @@ export function prepareScriptTools(language, context) {
     if (context.some((c) => c.type === 'db')) {
         tools.push(dbSchemaTool);
     }
+    if (['bun', 'deno'].includes(language)) {
+        tools.push(createSearchHubScriptsTool(true));
+        tools.push(searchNpmPackagesTool);
+    }
     return tools;
 }
 export async function prepareScriptUserMessage(instructions, language, selectedContext, options = {}) {
@@ -545,3 +567,123 @@ export const dbSchemaTool = {
         return stringSchema;
     }
 };
+const packagesSearchCache = new Map();
+export async function searchExternalIntegrationResources(args) {
+    try {
+        if (packagesSearchCache.has(args.query)) {
+            return JSON.stringify(packagesSearchCache.get(args.query));
+        }
+        const result = await fetch(`https://registry.npmjs.org/-/v1/search?text=${args.query}&size=2`);
+        const data = await result.json();
+        const filtered = data.objects.filter((r) => r.searchScore >= SCORE_THRESHOLD);
+        const modelContextWindow = getModelContextWindow(get(copilotSessionModel)?.model ?? '');
+        const results = await Promise.all(filtered.map(async (r) => {
+            let documentation = '';
+            let types = '';
+            try {
+                const docResponse = await fetch(`https://unpkg.com/${r.package.name}/readme.md`);
+                const docLimit = Math.floor((modelContextWindow * DOCS_CONTEXT_PERCENTAGE) / 100);
+                documentation = await docResponse.text();
+                documentation = documentation.slice(0, docLimit);
+            }
+            catch (error) {
+                console.error('Error getting documentation for package:', error);
+                documentation = '';
+            }
+            try {
+                const typesResponse = await fetchNpmPackageTypes(r.package.name, r.package.version);
+                const typesLimit = Math.floor((modelContextWindow * TYPES_CONTEXT_PERCENTAGE) / 100);
+                types = typesResponse.types.slice(0, typesLimit);
+            }
+            catch (error) {
+                console.error('Error getting types for package:', error);
+                types = '';
+            }
+            return {
+                package: r.package.name,
+                documentation: documentation,
+                types: types
+            };
+        }));
+        packagesSearchCache.set(args.query, results);
+        return JSON.stringify(results);
+    }
+    catch (error) {
+        console.error('Error searching external integration resources:', error);
+        return 'Error searching external integration resources';
+    }
+}
+const SEARCH_NPM_PACKAGES_TOOL = {
+    type: 'function',
+    function: {
+        name: 'search_npm_packages',
+        description: 'Search for npm packages and their documentation',
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The query to search for'
+                }
+            },
+            required: ['query']
+        }
+    }
+};
+export const searchNpmPackagesTool = {
+    def: SEARCH_NPM_PACKAGES_TOOL,
+    fn: async ({ args, toolId, toolCallbacks }) => {
+        toolCallbacks.setToolStatus(toolId, 'Searching for relevant packages...');
+        const result = await searchExternalIntegrationResources(args);
+        toolCallbacks.setToolStatus(toolId, 'Retrieved relevant packages');
+        return result;
+    }
+};
+export async function fetchNpmPackageTypes(packageName, version = 'latest') {
+    try {
+        const typeDefinitions = new Map();
+        const ata = setupTypeAcquisition({
+            projectName: 'NPM-Package-Types',
+            depsParser: () => [],
+            root: '',
+            delegate: {
+                receivedFile: (code, path) => {
+                    if (path.endsWith('.d.ts')) {
+                        typeDefinitions.set(path, code);
+                    }
+                },
+                localFile: () => { }
+            }
+        });
+        const depsToGet = [
+            {
+                raw: packageName,
+                module: packageName,
+                version: version
+            }
+        ];
+        await ata(depsToGet);
+        if (typeDefinitions.size === 0) {
+            return {
+                success: false,
+                types: '',
+                error: `No type definitions found for ${packageName}`
+            };
+        }
+        const formattedTypes = Array.from(typeDefinitions.entries())
+            .map(([path, content]) => `// ${path}\n${content}`)
+            .join('\n\n');
+        return {
+            success: true,
+            types: formattedTypes
+        };
+    }
+    catch (error) {
+        console.error('Error fetching NPM package types:', error);
+        return {
+            success: false,
+            types: '',
+            error: `Error fetching package types: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
+}

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

@@ -1,6 +1,7 @@
 import type { ChatCompletionMessageParam, ChatCompletionMessageToolCall, ChatCompletionTool } from 'openai/resources/chat/completions.mjs';
 import type { ContextElement } from './context';
 import type { ExtendedOpenFlow } from '../../flows/types';
+import { z } from 'zod';
 type BaseDisplayMessage = {
     content: string;
     contextElements?: ContextElement[];
@@ -44,4 +45,13 @@ export interface Tool<T> {
 export interface ToolCallbacks {
     setToolStatus: (id: string, content: string) => void;
 }
+export declare function createToolDef(zodSchema: z.ZodSchema, name: string, description: string): ChatCompletionTool;
+export declare const createSearchHubScriptsTool: (withContent?: boolean) => {
+    def: ChatCompletionTool;
+    fn: ({ args, toolId, toolCallbacks }: {
+        args: any;
+        toolId: any;
+        toolCallbacks: any;
+    }) => Promise<string>;
+};
 export {};

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

@@ -1,5 +1,8 @@
 import { get } from 'svelte/store';
 import { workspaceStore } from '../../../stores';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+import { z } from 'zod';
+import { ScriptService } from '../../../gen';
 async function callTool({ tools, functionName, args, workspace, helpers, toolCallbacks, toolId }) {
     const tool = tools.find((t) => t.def.function.name === functionName);
     if (!tool) {
@@ -37,3 +40,56 @@ export async function processToolCall({ tools, toolCall, messages, helpers, tool
         console.error(err);
     }
 }
+export function createToolDef(zodSchema, name, description) {
+    const schema = zodToJsonSchema(zodSchema, {
+        name,
+        target: 'openAi'
+    });
+    let parameters = schema.definitions[name];
+    parameters = {
+        ...parameters,
+        required: parameters.required ?? []
+    };
+    return {
+        type: 'function',
+        function: {
+            strict: true,
+            name,
+            description,
+            parameters
+        }
+    };
+}
+const searchHubScriptsSchema = z.object({
+    query: z
+        .string()
+        .describe('The query to search for, e.g. send email, list stripe invoices, etc..')
+});
+const searchHubScriptsToolDef = createToolDef(searchHubScriptsSchema, 'search_hub_scripts', 'Search for scripts in the hub');
+export const createSearchHubScriptsTool = (withContent = false) => ({
+    def: searchHubScriptsToolDef,
+    fn: async ({ args, toolId, toolCallbacks }) => {
+        toolCallbacks.setToolStatus(toolId, '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 + '"');
+        // 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 = '';
+            if (withContent) {
+                content = await ScriptService.getHubScriptContentByPath({
+                    path: `hub/${s.version_id}/${s.app}/${s.summary.toLowerCase().replaceAll(/\s+/g, '_')}`
+                });
+            }
+            return {
+                path: `hub/${s.version_id}/${s.app}/${s.summary.toLowerCase().replaceAll(/\s+/g, '_')}`,
+                summary: s.summary,
+                ...(withContent ? { content } : {})
+            };
+        }));
+        return JSON.stringify(results);
+    }
+});

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

@@ -18,6 +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 const PROVIDER_COMPLETION_CONFIG_MAP: Record<AIProvider, ChatCompletionCreateParams>;
 declare class WorkspacedAIClients {
     private openaiClient;