windmill-components 1.677.1 → 1.695.0

package/package/components/copilot/chat/workspaceTools.js

@@ -0,0 +1,239 @@
+import { AzureTriggerService, GcpTriggerService, HttpTriggerService, KafkaTriggerService, MqttTriggerService, NatsTriggerService, PostgresTriggerService, ScheduleService, SqsTriggerService, WebsocketTriggerService } from '../../../gen';
+import { createTriggerToolSchema, scheduleRequestSchema, triggerRequestSchemas } from './workspaceToolsZod.gen';
+import { z } from 'zod';
+import { createToolDef } from './shared';
+import { emptyString } from '../../../utils';
+const createScheduleToolSchema = scheduleRequestSchema.omit({ script_path: true, is_flow: true });
+function getWorkspaceMutationTarget(helpers) {
+    return helpers?.getWorkspaceMutationTarget?.();
+}
+function getWorkspaceMutationTargetError(target) {
+    if (!target) {
+        return 'the script or flow needs to be deployed before doing this action';
+    }
+    if (!emptyString(target.path) && target.deployed) {
+        return undefined;
+    }
+    return `the ${target.kind} needs to be deployed before doing this action`;
+}
+function validateWorkspaceMutationTarget(helpers) {
+    return getWorkspaceMutationTargetError(getWorkspaceMutationTarget(helpers));
+}
+function requireWorkspaceMutationTarget(helpers) {
+    const target = getWorkspaceMutationTarget(helpers);
+    const error = getWorkspaceMutationTargetError(target);
+    if (error) {
+        throw new Error(error);
+    }
+    return target;
+}
+function getWorkspaceMutationTargetFields(helpers) {
+    const target = requireWorkspaceMutationTarget(helpers);
+    return {
+        script_path: target.path,
+        is_flow: target.kind === 'flow'
+    };
+}
+const createScheduleToolDef = createToolDef(createScheduleToolSchema, 'create_schedule', 'Create a schedule for the current script or flow.', { strict: false });
+const createTriggerToolDef = createToolDef(createTriggerToolSchema, 'create_trigger', 'Create a trigger for the current script or flow.', { strict: false });
+const triggerConfigs = {
+    http: {
+        label: 'HTTP trigger',
+        requestSchema: triggerRequestSchemas.http,
+        create: (data) => HttpTriggerService.createHttpTrigger(data)
+    },
+    websocket: {
+        label: 'WebSocket trigger',
+        requestSchema: triggerRequestSchemas.websocket,
+        create: (data) => WebsocketTriggerService.createWebsocketTrigger(data)
+    },
+    kafka: {
+        label: 'Kafka trigger',
+        requestSchema: triggerRequestSchemas.kafka,
+        create: (data) => KafkaTriggerService.createKafkaTrigger(data)
+    },
+    nats: {
+        label: 'NATS trigger',
+        requestSchema: triggerRequestSchemas.nats,
+        create: (data) => NatsTriggerService.createNatsTrigger(data)
+    },
+    postgres: {
+        label: 'Postgres trigger',
+        requestSchema: triggerRequestSchemas.postgres,
+        create: (data) => PostgresTriggerService.createPostgresTrigger(data)
+    },
+    mqtt: {
+        label: 'MQTT trigger',
+        requestSchema: triggerRequestSchemas.mqtt,
+        create: (data) => MqttTriggerService.createMqttTrigger(data)
+    },
+    sqs: {
+        label: 'SQS trigger',
+        requestSchema: triggerRequestSchemas.sqs,
+        create: (data) => SqsTriggerService.createSqsTrigger(data)
+    },
+    gcp: {
+        label: 'GCP Pub/Sub trigger',
+        requestSchema: triggerRequestSchemas.gcp,
+        create: (data) => GcpTriggerService.createGcpTrigger(data)
+    },
+    azure: {
+        label: 'Azure Event Grid trigger',
+        requestSchema: triggerRequestSchemas.azure,
+        create: (data) => AzureTriggerService.createAzureTrigger(data)
+    }
+};
+function formatPath(path) {
+    if (path.length === 0) {
+        return 'value';
+    }
+    return path
+        .map((part) => (typeof part === 'number' ? `[${part}]` : String(part)))
+        .join('.')
+        .replaceAll('.[', '[');
+}
+function formatZodError(error) {
+    return error.issues
+        .slice(0, 8)
+        .map((issue) => `${formatPath(issue.path)}: ${issue.message}`)
+        .join('; ');
+}
+function parseWithExplicitErrors(schema, value, label) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        throw new Error(`${label} is invalid: ${formatZodError(result.error)}`);
+    }
+    return result.data;
+}
+function formatApiError(error) {
+    const bodyMessage = error?.body?.error?.message ??
+        error?.body?.message ??
+        (typeof error?.body?.error === 'string' ? error.body.error : undefined);
+    const body = bodyMessage ??
+        (typeof error?.body === 'string'
+            ? error.body
+            : error?.body !== undefined
+                ? stringifyErrorBody(error.body)
+                : undefined);
+    const message = body || error?.message || String(error);
+    return error?.status ? `HTTP ${error.status}: ${message}` : message;
+}
+function stringifyErrorBody(body) {
+    try {
+        return JSON.stringify(body);
+    }
+    catch {
+        return String(body);
+    }
+}
+function setToolError(toolCallbacks, toolId, error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    toolCallbacks.setToolStatus(toolId, {
+        content: errorMessage,
+        error: errorMessage,
+        isLoading: false,
+        needsConfirmation: false
+    });
+    return `Error while calling tool: ${errorMessage}`;
+}
+const createScheduleTool = {
+    def: createScheduleToolDef,
+    requiresConfirmation: true,
+    confirmationMessage: 'Create schedule',
+    showDetails: true,
+    validateBeforeConfirmation: ({ helpers }) => validateWorkspaceMutationTarget(helpers),
+    fn: async ({ args, workspace, helpers, toolCallbacks, toolId }) => {
+        try {
+            const requestBody = parseWithExplicitErrors(scheduleRequestSchema, {
+                ...args,
+                ...getWorkspaceMutationTargetFields(helpers)
+            }, 'Schedule');
+            toolCallbacks.setToolStatus(toolId, {
+                content: `Validating schedule "${requestBody.path}"...`
+            });
+            try {
+                await ScheduleService.previewSchedule({
+                    requestBody: {
+                        schedule: requestBody.schedule,
+                        timezone: requestBody.timezone,
+                        cron_version: requestBody.cron_version ?? undefined
+                    }
+                });
+            }
+            catch (error) {
+                throw new Error(`Invalid schedule or timezone: ${formatApiError(error)}`);
+            }
+            toolCallbacks.setToolStatus(toolId, {
+                content: `Creating schedule "${requestBody.path}"...`
+            });
+            try {
+                const result = await ScheduleService.createSchedule({ workspace, requestBody });
+                const toolResult = {
+                    success: true,
+                    path: requestBody.path,
+                    target_path: requestBody.script_path,
+                    target_kind: requestBody.is_flow ? 'flow' : 'script',
+                    backend_result: result
+                };
+                toolCallbacks.setToolStatus(toolId, {
+                    content: `Created schedule "${requestBody.path}"`,
+                    result: toolResult
+                });
+                return JSON.stringify(toolResult);
+            }
+            catch (error) {
+                throw new Error(`Failed to create schedule "${requestBody.path}": ${formatApiError(error)}`);
+            }
+        }
+        catch (error) {
+            return setToolError(toolCallbacks, toolId, error);
+        }
+    }
+};
+const createTriggerTool = {
+    def: createTriggerToolDef,
+    requiresConfirmation: true,
+    confirmationMessage: 'Create trigger',
+    showDetails: true,
+    validateBeforeConfirmation: ({ helpers }) => validateWorkspaceMutationTarget(helpers),
+    fn: async ({ args, workspace, helpers, toolCallbacks, toolId }) => {
+        try {
+            const parsedArgs = parseWithExplicitErrors(createTriggerToolSchema, args, 'Trigger');
+            const triggerConfig = triggerConfigs[parsedArgs.kind];
+            const requestBody = parseWithExplicitErrors(triggerConfig.requestSchema, {
+                ...parsedArgs.config,
+                path: parsedArgs.path,
+                ...getWorkspaceMutationTargetFields(helpers)
+            }, triggerConfig.label);
+            toolCallbacks.setToolStatus(toolId, {
+                content: `Creating ${triggerConfig.label} "${requestBody.path}"...`
+            });
+            try {
+                const result = await triggerConfig.create({ workspace, requestBody });
+                const toolResult = {
+                    success: true,
+                    kind: parsedArgs.kind,
+                    path: requestBody.path,
+                    target_path: requestBody.script_path,
+                    target_kind: requestBody.is_flow ? 'flow' : 'script',
+                    backend_result: result
+                };
+                toolCallbacks.setToolStatus(toolId, {
+                    content: `Created ${triggerConfig.label} "${requestBody.path}"`,
+                    result: toolResult
+                });
+                return JSON.stringify(toolResult);
+            }
+            catch (error) {
+                throw new Error(`Failed to create ${triggerConfig.label} "${requestBody.path}": ${formatApiError(error)}`);
+            }
+        }
+        catch (error) {
+            return setToolError(toolCallbacks, toolId, error);
+        }
+    }
+};
+const workspaceMutationTools = [createScheduleTool, createTriggerTool];
+export function createWorkspaceMutationTools() {
+    return workspaceMutationTools;
+}