windmill-components 1.687.0 → 1.695.1

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

@@ -0,0 +1,412 @@
+import { describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+vi.mock('monaco-editor', () => ({
+    editor: {}
+}));
+vi.mock('$lib/stores', () => ({
+    workspaceStore: { subscribe: () => () => undefined }
+}));
+vi.mock('$lib/components/flows/flowTree', () => ({
+    findModuleInModules: () => undefined
+}));
+vi.mock('$lib/gen', () => ({
+    ScriptService: {},
+    FlowService: {},
+    JobService: {},
+    ScheduleService: {
+        previewSchedule: vi.fn(),
+        createSchedule: vi.fn()
+    },
+    HttpTriggerService: { createHttpTrigger: vi.fn() },
+    WebsocketTriggerService: { createWebsocketTrigger: vi.fn() },
+    KafkaTriggerService: { createKafkaTrigger: vi.fn() },
+    NatsTriggerService: { createNatsTrigger: vi.fn() },
+    PostgresTriggerService: { createPostgresTrigger: vi.fn() },
+    MqttTriggerService: { createMqttTrigger: vi.fn() },
+    SqsTriggerService: { createSqsTrigger: vi.fn() },
+    GcpTriggerService: { createGcpTrigger: vi.fn() },
+    AzureTriggerService: { createAzureTrigger: vi.fn() }
+}));
+vi.mock('$lib/utils', () => ({
+    emptyString: (value) => !value
+}));
+vi.mock('$lib/scripts', () => ({
+    scriptLangToEditorLang: (language) => language
+}));
+vi.mock('$lib/aiStore', () => ({
+    getCurrentModel: () => undefined
+}));
+vi.mock('@leeoniya/ufuzzy', () => ({
+    default: class {
+        search() {
+            return [[], [], []];
+        }
+    }
+}));
+describe('createToolDef', () => {
+    it('builds the create_trigger schema without top-level composition', async () => {
+        const { createToolDef } = await import('./shared');
+        const { createTriggerToolSchema } = await import('./workspaceToolsZod.gen');
+        const toolDef = createToolDef(createTriggerToolSchema, 'create_trigger', 'Create a trigger');
+        const parameters = toolDef.function.parameters;
+        expect(parameters).toBeDefined();
+        expect(parameters?.type).toBe('object');
+        expect(parameters?.anyOf).toBeUndefined();
+        expect(parameters?.oneOf).toBeUndefined();
+        expect(parameters?.allOf).toBeUndefined();
+        expect(parameters?.properties?.kind?.enum).toContain('http');
+        expect(parameters?.properties?.config?.anyOf?.length).toBeGreaterThan(1);
+    });
+    it('does not expose runnable target fields on workspace mutation tools', async () => {
+        const { createWorkspaceMutationTools } = await import('./workspaceTools');
+        const [scheduleTool, triggerTool] = createWorkspaceMutationTools();
+        const scheduleParameters = scheduleTool.def.function.parameters;
+        expect(scheduleParameters?.properties?.script_path).toBeUndefined();
+        expect(scheduleParameters?.properties?.is_flow).toBeUndefined();
+        const triggerParameters = triggerTool.def.function.parameters;
+        const triggerConfigVariants = triggerParameters?.properties?.config?.anyOf ?? [];
+        expect(triggerConfigVariants.length).toBeGreaterThan(1);
+        for (const variant of triggerConfigVariants) {
+            expect(variant?.properties?.script_path).toBeUndefined();
+            expect(variant?.properties?.is_flow).toBeUndefined();
+        }
+    });
+});
+describe('processToolCall', () => {
+    it('returns pre-confirmation validation errors without asking for confirmation', async () => {
+        const { createToolDef, processToolCall } = await import('./shared');
+        const error = 'the script needs to be deployed before doing this action';
+        const fn = vi.fn();
+        const requestConfirmation = vi.fn();
+        const setToolStatus = vi.fn();
+        const result = await processToolCall({
+            tools: [
+                {
+                    def: createToolDef(z.object({}), 'create_schedule', 'Create schedule'),
+                    requiresConfirmation: true,
+                    showDetails: true,
+                    validateBeforeConfirmation: () => error,
+                    fn
+                }
+            ],
+            toolCall: {
+                id: 'call_1',
+                type: 'function',
+                function: { name: 'create_schedule', arguments: '{}' }
+            },
+            helpers: {},
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation
+            }
+        });
+        expect(requestConfirmation).not.toHaveBeenCalled();
+        expect(fn).not.toHaveBeenCalled();
+        expect(setToolStatus).toHaveBeenCalledWith('call_1', expect.objectContaining({
+            content: error,
+            error,
+            isLoading: false,
+            needsConfirmation: false,
+            showDetails: true
+        }));
+        expect(result.content).toBe(error);
+    });
+    it('continues to confirmation when pre-confirmation validation passes', async () => {
+        const { createToolDef, processToolCall } = await import('./shared');
+        const fn = vi.fn().mockResolvedValue('ok');
+        const requestConfirmation = vi.fn().mockResolvedValue(true);
+        const setToolStatus = vi.fn();
+        const result = await processToolCall({
+            tools: [
+                {
+                    def: createToolDef(z.object({}), 'create_schedule', 'Create schedule'),
+                    requiresConfirmation: true,
+                    confirmationMessage: 'Create schedule',
+                    validateBeforeConfirmation: () => undefined,
+                    fn
+                }
+            ],
+            toolCall: {
+                id: 'call_2',
+                type: 'function',
+                function: { name: 'create_schedule', arguments: '{}' }
+            },
+            helpers: {},
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation
+            }
+        });
+        expect(requestConfirmation).toHaveBeenCalledWith('call_2');
+        expect(fn).toHaveBeenCalled();
+        expect(result.content).toBe('ok');
+    });
+    it('blocks workspace mutation tools for undeployed scripts and flows', async () => {
+        const { processToolCall } = await import('./shared');
+        const { createWorkspaceMutationTools } = await import('./workspaceTools');
+        const setToolStatus = vi.fn();
+        const requestConfirmation = vi.fn();
+        const workspaceMutationTools = createWorkspaceMutationTools();
+        const scriptResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_3',
+                type: 'function',
+                function: { name: 'create_schedule', arguments: '{}' }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({ kind: 'script', path: '', deployed: false })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation
+            }
+        });
+        expect(scriptResult.content).toBe('the script needs to be deployed before doing this action');
+        const flowResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_4',
+                type: 'function',
+                function: { name: 'create_trigger', arguments: '{}' }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({ kind: 'flow', path: 'f/flow', deployed: false })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation
+            }
+        });
+        expect(flowResult.content).toBe('the flow needs to be deployed before doing this action');
+        expect(requestConfirmation).not.toHaveBeenCalled();
+    });
+    it('injects runnable target fields into schedule and trigger requests', async () => {
+        const gen = (await import('../../../gen'));
+        const { processToolCall } = await import('./shared');
+        const { createWorkspaceMutationTools } = await import('./workspaceTools');
+        const workspaceMutationTools = createWorkspaceMutationTools();
+        gen.ScheduleService.previewSchedule.mockReset();
+        gen.ScheduleService.createSchedule.mockReset();
+        gen.HttpTriggerService.createHttpTrigger.mockReset();
+        gen.ScheduleService.previewSchedule.mockResolvedValue({});
+        gen.ScheduleService.createSchedule.mockResolvedValue('schedule-created');
+        gen.HttpTriggerService.createHttpTrigger.mockResolvedValue('trigger-created');
+        const scheduleSetToolStatus = vi.fn();
+        const scheduleResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_5',
+                type: 'function',
+                function: {
+                    name: 'create_schedule',
+                    arguments: JSON.stringify({
+                        path: 'f/schedules/current',
+                        schedule: '0 0 12 * * *',
+                        timezone: 'UTC',
+                        args: null
+                    })
+                }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({
+                    kind: 'script',
+                    path: 'f/scripts/current',
+                    deployed: true
+                })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus: scheduleSetToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation: vi.fn().mockResolvedValue(true)
+            }
+        });
+        expect(gen.ScheduleService.createSchedule).toHaveBeenCalledWith({
+            workspace: 'test-workspace',
+            requestBody: expect.objectContaining({
+                script_path: 'f/scripts/current',
+                is_flow: false
+            })
+        });
+        expect(scheduleSetToolStatus).toHaveBeenCalledWith('call_5', expect.objectContaining({
+            result: expect.objectContaining({
+                success: true,
+                path: 'f/schedules/current',
+                target_path: 'f/scripts/current',
+                target_kind: 'script',
+                backend_result: 'schedule-created'
+            })
+        }));
+        expect(JSON.parse(scheduleResult.content)).toEqual(expect.objectContaining({
+            success: true,
+            path: 'f/schedules/current',
+            target_path: 'f/scripts/current',
+            target_kind: 'script',
+            backend_result: 'schedule-created'
+        }));
+        const triggerSetToolStatus = vi.fn();
+        const triggerResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_6',
+                type: 'function',
+                function: {
+                    name: 'create_trigger',
+                    arguments: JSON.stringify({
+                        kind: 'http',
+                        path: 'f/triggers/current',
+                        config: {
+                            route_path: 'api/current',
+                            http_method: 'post',
+                            authentication_method: 'none',
+                            is_static_website: false
+                        }
+                    })
+                }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({
+                    kind: 'flow',
+                    path: 'f/flows/current',
+                    deployed: true
+                })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus: triggerSetToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation: vi.fn().mockResolvedValue(true)
+            }
+        });
+        expect(gen.HttpTriggerService.createHttpTrigger).toHaveBeenCalledWith({
+            workspace: 'test-workspace',
+            requestBody: expect.objectContaining({
+                script_path: 'f/flows/current',
+                is_flow: true
+            })
+        });
+        expect(triggerSetToolStatus).toHaveBeenCalledWith('call_6', expect.objectContaining({
+            result: expect.objectContaining({
+                success: true,
+                kind: 'http',
+                path: 'f/triggers/current',
+                target_path: 'f/flows/current',
+                target_kind: 'flow',
+                backend_result: 'trigger-created'
+            })
+        }));
+        expect(JSON.parse(triggerResult.content)).toEqual(expect.objectContaining({
+            success: true,
+            kind: 'http',
+            path: 'f/triggers/current',
+            target_path: 'f/flows/current',
+            target_kind: 'flow',
+            backend_result: 'trigger-created'
+        }));
+    });
+    it('surfaces workspace mutation tool execution errors to the user', async () => {
+        const gen = (await import('../../../gen'));
+        const { processToolCall } = await import('./shared');
+        const { createWorkspaceMutationTools } = await import('./workspaceTools');
+        const workspaceMutationTools = createWorkspaceMutationTools();
+        gen.ScheduleService.previewSchedule.mockReset();
+        gen.ScheduleService.createSchedule.mockReset();
+        gen.HttpTriggerService.createHttpTrigger.mockReset();
+        gen.ScheduleService.previewSchedule.mockRejectedValue(new Error('backend rejected schedule'));
+        const scheduleSetToolStatus = vi.fn();
+        const scheduleError = 'Invalid schedule or timezone: backend rejected schedule';
+        const scheduleResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_7',
+                type: 'function',
+                function: {
+                    name: 'create_schedule',
+                    arguments: JSON.stringify({
+                        path: 'f/schedules/current',
+                        schedule: '0 0 12 * * *',
+                        timezone: 'UTC',
+                        args: null
+                    })
+                }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({
+                    kind: 'script',
+                    path: 'f/scripts/current',
+                    deployed: true
+                })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus: scheduleSetToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation: vi.fn().mockResolvedValue(true)
+            }
+        });
+        expect(scheduleSetToolStatus).toHaveBeenCalledWith('call_7', expect.objectContaining({
+            content: scheduleError,
+            error: scheduleError,
+            isLoading: false
+        }));
+        expect(scheduleResult.content).toBe(`Error while calling tool: ${scheduleError}`);
+        expect(scheduleSetToolStatus).not.toHaveBeenCalledWith('call_7', expect.objectContaining({
+            error: 'An error occurred while calling the tool'
+        }));
+        gen.ScheduleService.previewSchedule.mockResolvedValue({});
+        gen.HttpTriggerService.createHttpTrigger.mockRejectedValue(new Error('backend rejected trigger'));
+        const triggerSetToolStatus = vi.fn();
+        const triggerError = 'Failed to create HTTP trigger "f/triggers/current": backend rejected trigger';
+        const triggerResult = await processToolCall({
+            tools: workspaceMutationTools,
+            toolCall: {
+                id: 'call_8',
+                type: 'function',
+                function: {
+                    name: 'create_trigger',
+                    arguments: JSON.stringify({
+                        kind: 'http',
+                        path: 'f/triggers/current',
+                        config: {
+                            route_path: 'api/current',
+                            http_method: 'post',
+                            authentication_method: 'none',
+                            is_static_website: false
+                        }
+                    })
+                }
+            },
+            helpers: {
+                getWorkspaceMutationTarget: () => ({
+                    kind: 'flow',
+                    path: 'f/flows/current',
+                    deployed: true
+                })
+            },
+            workspace: 'test-workspace',
+            toolCallbacks: {
+                setToolStatus: triggerSetToolStatus,
+                removeToolStatus: vi.fn(),
+                requestConfirmation: vi.fn().mockResolvedValue(true)
+            }
+        });
+        expect(triggerSetToolStatus).toHaveBeenCalledWith('call_8', expect.objectContaining({
+            content: triggerError,
+            error: triggerError,
+            isLoading: false
+        }));
+        expect(triggerResult.content).toBe(`Error while calling tool: ${triggerError}`);
+        expect(triggerSetToolStatus).not.toHaveBeenCalledWith('call_8', expect.objectContaining({
+            error: 'An error occurred while calling the tool'
+        }));
+    });
+});

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

@@ -0,0 +1,7 @@
+import { type Tool } from './shared';
+export type WorkspaceMutationTarget = {
+    kind: 'script' | 'flow';
+    path?: string;
+    deployed?: boolean;
+};
+export declare function createWorkspaceMutationTools<T>(): Tool<T>[];

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;
+}