@artflo-ai/artflo-openclaw-plugin 0.0.1

package/dist/src/tools/register-tools.js

@@ -0,0 +1,669 @@
+import { Type } from '@sinclair/typebox';
+/**
+ * Format a tool result payload for the openclaw agent runtime.
+ *
+ * This is a local implementation identical to `jsonResult` from
+ * `openclaw/plugin-sdk`.  We define it here because the openclaw plugin
+ * loader may use a CJS interop layer that cannot resolve the named ESM
+ * export at runtime (error: `_pluginSdk.jsonResult is not a function`).
+ */
+function jsonResult(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        details: payload,
+    };
+}
+import { ARTFLO_TOOL_NAMES } from '../constants.js';
+import { createCanvas } from '../core/canvas/create-canvas.js';
+import { uploadFile } from '../core/api/upload-file.js';
+import { fetchVipInfo } from '../core/config/fetch-vip-info.js';
+import { transformCanvasConfig } from '../core/config/model-config-transformer.js';
+import { executePlan as runExecutePlan } from '../core/executor/execute-plan.js';
+import { ExecutionTraceWriter } from '../core/executor/execution-trace.js';
+import { parsePlanV2, validateAndFixPlan } from '../core/plan/validate-plan.js';
+import { writeToolTrace } from './tool-trace.js';
+export function registerArtfloTools(api, context) {
+    const registerOptionalTool = (tool) => {
+        api.registerTool(tool, { optional: true });
+    };
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.getNode,
+        label: 'Artflo Canvas Get Node',
+        description: 'Read one node or edge from the current Artflo canvas session by id.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            id: Type.String({ minLength: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.getNode, params, async () => {
+                const { canvasId, id } = params;
+                const session = context.sessions.getOrCreate(canvasId);
+                await session.connect({ canvasId });
+                const element = session.getElement(id) ?? null;
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.getNode,
+                    data: {
+                        canvasId,
+                        element,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.connect,
+        label: 'Artflo Canvas Connect',
+        description: 'Register or warm a direct Artflo canvas WebSocket session for a canvas id using preconfigured plugin credentials.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.connect, params, async () => {
+                const canvasId = params.canvasId;
+                const session = context.sessions.getOrCreate(canvasId);
+                const elements = await session.connect({
+                    canvasId,
+                });
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.connect,
+                    data: {
+                        session: session.getConnectionState(),
+                        elementCount: elements.length,
+                        configuredApiBaseUrl: context.config.apiBaseUrl,
+                        hasApiKey: context.config.apiKey.length > 0,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.connectionStatus,
+        label: 'Artflo Canvas Connection Status',
+        description: 'Inspect current plugin-level Artflo WebSocket session state and config readiness.',
+        parameters: Type.Object({
+            canvasId: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.connectionStatus, params, async () => {
+                const canvasId = params.canvasId;
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.connectionStatus,
+                    data: canvasId
+                        ? {
+                            session: context.sessions.get(canvasId)?.getConnectionState() ?? null,
+                            status: context.sessions.getStatus(),
+                        }
+                        : {
+                            sessions: context.sessions
+                                .getAll()
+                                .map((session) => session.getConnectionState()),
+                            status: context.sessions.getStatus(),
+                        },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.getState,
+        label: 'Artflo Canvas State',
+        description: 'Return scaffold plugin state and planned runtime capabilities for Artflo execution.',
+        parameters: Type.Object({
+            canvasId: Type.Optional(Type.String()),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.getState, params, async () => {
+                const canvasId = params.canvasId;
+                const session = canvasId ? context.sessions.get(canvasId) : null;
+                const elements = session?.getElements() ?? [];
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.getState,
+                    data: {
+                        stage: 'canvas-runtime-connected',
+                        capabilities: [
+                            'direct_websocket_runtime_ready',
+                            'layout_engine_planned',
+                            'plan_validation_planned',
+                            'execute_plan_planned',
+                        ],
+                        status: context.sessions.getStatus(),
+                        canvasId: canvasId ?? null,
+                        elementCount: elements.length,
+                        elementsPreview: elements.slice(0, 10).map((element) => ({
+                            id: element.id,
+                            type: element.type,
+                            position: element.position ?? null,
+                        })),
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.getConfig,
+        label: 'Artflo Canvas Get Config',
+        description: 'Return available models, subscription status, and prompt refine categories for the connected canvas. Call this before planning a workflow so you know which models and resolutions are available.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.getConfig, params, async () => {
+                const canvasId = params.canvasId;
+                const session = context.sessions.getOrCreate(canvasId);
+                await session.connect({ canvasId });
+                const canvasConfig = session.getCanvasConfig();
+                const vipInfo = await fetchVipInfo(context.config);
+                const llmConfig = canvasConfig
+                    ? transformCanvasConfig(canvasConfig, vipInfo.isVip)
+                    : null;
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.getConfig,
+                    data: {
+                        canvasId,
+                        subscription: {
+                            isVip: vipInfo.isVip,
+                            membershipLevel: vipInfo.membershipLevel,
+                            membershipName: vipInfo.membershipName,
+                        },
+                        models: llmConfig?.categories ?? [],
+                        outputTools: llmConfig?.outputTools ?? [],
+                        promptRefineCategories: llmConfig?.promptRefineCategories ?? [],
+                        hasCanvasConfig: canvasConfig !== null,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.findNodes,
+        label: 'Artflo Canvas Find Nodes',
+        description: 'Find nodes or edges in the connected Artflo canvas by ids, type, status, label text, or runnable state.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            ids: Type.Optional(Type.Array(Type.String())),
+            type: Type.Optional(Type.Number()),
+            labelIncludes: Type.Optional(Type.String()),
+            status: Type.Optional(Type.Number()),
+            runnable: Type.Optional(Type.Boolean()),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.findNodes, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                const matched = session.getElements().filter((element) => {
+                    if (payload.ids?.length && !payload.ids.includes(element.id)) {
+                        return false;
+                    }
+                    if (typeof payload.type === 'number' && element.type !== payload.type) {
+                        return false;
+                    }
+                    if (typeof payload.status === 'number') {
+                        const currentStatus = typeof element.data.status === 'number'
+                            ? Number(element.data.status)
+                            : undefined;
+                        if (currentStatus !== payload.status) {
+                            return false;
+                        }
+                    }
+                    if (typeof payload.runnable === 'boolean') {
+                        const runnable = isRunnableElement(element);
+                        if (runnable !== payload.runnable) {
+                            return false;
+                        }
+                    }
+                    if (payload.labelIncludes) {
+                        const label = readElementLabel(element).toLowerCase();
+                        if (!label.includes(payload.labelIncludes.toLowerCase())) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.findNodes,
+                    data: {
+                        canvasId: payload.canvasId,
+                        count: matched.length,
+                        elements: matched,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.changeElements,
+        label: 'Artflo Canvas Change Elements',
+        description: 'Apply direct structured element changes to an existing Artflo canvas session.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            changes: Type.Array(Type.Any(), { minItems: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.changeElements, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                await session.changeElements(payload.changes);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.changeElements,
+                    data: {
+                        canvasId: payload.canvasId,
+                        changedIds: payload.changes
+                            .map((change) => change.id)
+                            .filter((id) => typeof id === 'string'),
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.deleteElements,
+        label: 'Artflo Canvas Delete Elements',
+        description: 'Delete nodes or edges from the current Artflo canvas session.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            ids: Type.Array(Type.String(), { minItems: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.deleteElements, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                await session.deleteElements(payload.ids);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.deleteElements,
+                    data: {
+                        canvasId: payload.canvasId,
+                        deletedIds: payload.ids,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.runNodes,
+        label: 'Artflo Canvas Run Nodes',
+        description: 'Run one or more executable Artflo nodes by id.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            ids: Type.Array(Type.String(), { minItems: 1 }),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.runNodes, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                await session.executeNodes(payload.ids);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.runNodes,
+                    data: {
+                        canvasId: payload.canvasId,
+                        executedNodeIds: payload.ids,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.waitForCompletion,
+        label: 'Artflo Canvas Wait For Completion',
+        description: 'Wait for one or more executable nodes to reach completion status.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            ids: Type.Array(Type.String(), { minItems: 1 }),
+            timeoutMs: Type.Optional(Type.Number()),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.waitForCompletion, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                const completed = await session.waitForCompletion(payload.ids, payload.timeoutMs ?? 300_000);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.waitForCompletion,
+                    data: {
+                        canvasId: payload.canvasId,
+                        ids: payload.ids,
+                        completed,
+                    },
+                });
+            });
+        },
+    });
+    registerOptionalTool({
+        name: ARTFLO_TOOL_NAMES.executePlan,
+        label: 'Artflo Execute Plan',
+        description: 'Execute a structured Artflo plan through deterministic runtime logic. In scaffold phase, validates request shape and returns the next integration milestone.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            plan: Type.Object({
+                nodes: Type.Array(Type.Any()),
+                edges: Type.Array(Type.Any()),
+                description: Type.Optional(Type.String()),
+                planId: Type.Optional(Type.String()),
+                version: Type.Optional(Type.String()),
+            }),
+            selectedNodeIds: Type.Optional(Type.Array(Type.String())),
+            draft: Type.Optional(Type.Boolean()),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.executePlan, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({
+                    canvasId: payload.canvasId,
+                });
+                const parsedPlan = parsePlanV2(payload.plan);
+                const validated = validateAndFixPlan(parsedPlan);
+                const traceWriter = await ExecutionTraceWriter.create({
+                    planId: validated.plan.planId,
+                    canvasId: payload.canvasId,
+                });
+                const execution = payload.draft === true
+                    ? null
+                    : await runExecutePlan({
+                        plan: validated.plan,
+                        session,
+                        traceWriter,
+                    });
+                if (payload.draft === true) {
+                    await traceWriter.writeMeta('draft-only', {
+                        canvasId: payload.canvasId,
+                        fixes: validated.fixes,
+                        selectedNodeIds: payload.selectedNodeIds ?? [],
+                        draft: true,
+                        plan: validated.plan,
+                    });
+                }
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.executePlan,
+                    data: {
+                        accepted: true,
+                        stage: 'canvas-runtime-connected',
+                        canvasId: payload.canvasId,
+                        session: session.getConnectionState(),
+                        nodeCount: validated.plan.nodes.length,
+                        edgeCount: validated.plan.edges.length,
+                        selectedNodeIds: payload.selectedNodeIds ?? [],
+                        draft: payload.draft ?? false,
+                        planId: validated.plan.planId,
+                        description: validated.plan.description,
+                        fixes: validated.fixes,
+                        execution,
+                        traceDirectory: execution?.traceDirectory ?? traceWriter.directory,
+                        ok: execution ? execution.executionCompleted !== false : true,
+                        nextStep: 'Next: add smarter handles, executable node runs, and advanced batch/layout orchestration.',
+                    },
+                });
+            });
+        },
+    });
+    api.registerTool({
+        name: ARTFLO_TOOL_NAMES.createCanvas,
+        label: 'Artflo Canvas Create',
+        description: 'Create a new Artflo canvas project. Returns the canvas id and project URL. Use this when no canvas id is available or the user requests a new canvas.',
+        parameters: Type.Object({
+            name: Type.Optional(Type.String({ description: 'Canvas name, defaults to "Untitled"' })),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.createCanvas, params, async () => {
+                const name = params.name || 'Untitled';
+                const result = await createCanvas(context.config, name);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.createCanvas,
+                    data: {
+                        canvasId: result.id,
+                        name: result.name,
+                        url: result.url,
+                    },
+                });
+            });
+        },
+    });
+    api.registerTool({
+        name: ARTFLO_TOOL_NAMES.listModels,
+        label: 'Artflo Canvas List Models',
+        description: 'List all available AI models with their names, subscription requirements, default status, and credit costs. Video model credits are per-second. Use this to help users understand what models are available before planning a workflow.',
+        parameters: Type.Object({
+            canvasId: Type.String({ minLength: 1 }),
+            category: Type.Optional(Type.String({
+                description: 'Filter by category: "text2image", "image2image", "text2video", "image2video", "image23d". Omit to list all.',
+            })),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.listModels, params, async () => {
+                const payload = params;
+                const session = context.sessions.getOrCreate(payload.canvasId);
+                await session.connect({ canvasId: payload.canvasId });
+                const canvasConfig = session.getCanvasConfig();
+                const vipInfo = await fetchVipInfo(context.config);
+                if (!canvasConfig) {
+                    return jsonResult({
+                        ok: false,
+                        label: ARTFLO_TOOL_NAMES.listModels,
+                        error: 'Canvas config not available',
+                    });
+                }
+                const VIDEO_TOOL_TYPES = new Set([3, 4]);
+                const CATEGORY_MAP = {
+                    text2image: { key: 'text_to_image_model', toolType: 1, label: 'Text to Image' },
+                    image2image: { key: 'image_to_image_model', toolType: 2, label: 'Image to Image' },
+                    text2video: { key: 'text_to_video_model', toolType: 3, label: 'Text to Video' },
+                    image2video: { key: 'image_to_video_model', toolType: 4, label: 'Image to Video' },
+                    image23d: { key: 'image_to_3d_model', toolType: 8, label: 'Image to 3D' },
+                };
+                const categoriesToList = payload.category
+                    ? { [payload.category.toLowerCase()]: CATEGORY_MAP[payload.category.toLowerCase()] }
+                    : CATEGORY_MAP;
+                const result = [];
+                for (const [, info] of Object.entries(categoriesToList)) {
+                    if (!info)
+                        continue;
+                    const models = canvasConfig[info.key];
+                    if (!Array.isArray(models) || models.length === 0)
+                        continue;
+                    const isVideo = VIDEO_TOOL_TYPES.has(info.toolType);
+                    const mapped = models.map((m) => {
+                        const modelAvailable = !m.disable &&
+                            (!m.subscribe_available || vipInfo.isVip || m.is_free_limit);
+                        // Build per-resolution pricing
+                        const resolutionPricing = m.multi_config_price && Object.keys(m.multi_config_price).length > 0
+                            ? Object.fromEntries(Object.entries(m.multi_config_price).map(([key, price]) => {
+                                const label = key.replace('resolution_', '').toUpperCase();
+                                const needsSub = m.multi_subscribe?.[key] === true;
+                                return [
+                                    label,
+                                    {
+                                        credits: isVideo ? `${price} credits/sec` : `${price} credits`,
+                                        ...(needsSub ? { requiresSubscription: true } : {}),
+                                    },
+                                ];
+                            }))
+                            : undefined;
+                        const item = {
+                            name: m.model_name,
+                            modelKey: m.model_key,
+                            isDefault: m.is_default,
+                            requiresSubscription: m.subscribe_available,
+                            available: modelAvailable,
+                            credits: isVideo
+                                ? `${m.price} credits/sec`
+                                : `${m.price} credits`,
+                        };
+                        if (m.support_resolution?.length) {
+                            item.supportedResolutions = m.support_resolution;
+                            if (m.default_resolution)
+                                item.defaultResolution = m.default_resolution;
+                        }
+                        if (m.support_ratio?.length)
+                            item.supportedRatios = m.support_ratio;
+                        if (m.support_duration?.length)
+                            item.supportedDurations = m.support_duration;
+                        if (resolutionPricing)
+                            item.resolutionPricing = resolutionPricing;
+                        return item;
+                    });
+                    result.push({ category: info.label, models: mapped });
+                }
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.listModels,
+                    data: {
+                        subscription: {
+                            isVip: vipInfo.isVip,
+                            membershipLevel: vipInfo.membershipLevel,
+                            pricingUrl: 'https://artflo.ai/pricing',
+                        },
+                        hint: vipInfo.isVip
+                            ? undefined
+                            : 'User is not subscribed. Models or resolutions marked requiresSubscription need a subscription. Visit https://artflo.ai/pricing to subscribe, or use free models.',
+                        categories: result,
+                    },
+                });
+            });
+        },
+    });
+    api.registerTool({
+        name: ARTFLO_TOOL_NAMES.uploadFile,
+        label: 'Artflo Upload File',
+        description: 'Upload a local file or a remote URL to Artflo OBS storage. Returns the CDN URL and object key. Use this to upload reference images before creating workflows with image-to-image or image-to-video nodes.',
+        parameters: Type.Object({
+            source: Type.String({
+                description: 'Local file path or remote https URL to upload.',
+            }),
+            filename: Type.Optional(Type.String({ description: 'Override filename for the upload.' })),
+        }),
+        async execute(_id, params) {
+            return runWithToolTrace(ARTFLO_TOOL_NAMES.uploadFile, params, async () => {
+                const payload = params;
+                const result = await uploadFile(context.config, payload.source, payload.filename);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.uploadFile,
+                    data: {
+                        url: result.url,
+                        key: result.key,
+                    },
+                });
+            });
+        },
+    });
+    api.registerTool({
+        name: ARTFLO_TOOL_NAMES.setApiKey,
+        label: 'Artflo Set API Key',
+        description: 'Save the user\'s Artflo API Key to the plugin config and restart the gateway. Call this when the user provides their API Key in chat. After success, the gateway will restart and all Artflo tools will be functional.',
+        parameters: Type.Object({
+            apiKey: Type.String({ minLength: 1, description: 'The Artflo API Key provided by the user.' }),
+        }),
+        async execute(_id, params) {
+            const { apiKey } = params;
+            try {
+                const cfg = api.runtime.config.loadConfig();
+                const pluginEntry = cfg.plugins?.entries?.['artflo-openclaw-plugin'] ?? {};
+                const existingConfig = pluginEntry.config ?? {};
+                const nextConfig = {
+                    ...cfg,
+                    plugins: {
+                        ...cfg.plugins,
+                        entries: {
+                            ...cfg.plugins?.entries,
+                            'artflo-openclaw-plugin': {
+                                ...pluginEntry,
+                                enabled: true,
+                                config: {
+                                    ...existingConfig,
+                                    apiKey,
+                                },
+                            },
+                        },
+                    },
+                };
+                await api.runtime.config.writeConfigFile(nextConfig);
+                return jsonResult({
+                    ok: true,
+                    label: ARTFLO_TOOL_NAMES.setApiKey,
+                    data: {
+                        message: 'API Key saved. Please restart gateway with: openclaw gateway restart',
+                        saved: true,
+                    },
+                });
+            }
+            catch (err) {
+                return jsonResult({
+                    ok: false,
+                    label: ARTFLO_TOOL_NAMES.setApiKey,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        },
+    });
+}
+async function runWithToolTrace(toolName, params, run) {
+    const canvasId = typeof params === 'object' &&
+        params !== null &&
+        'canvasId' in params &&
+        typeof params.canvasId === 'string'
+        ? params.canvasId
+        : undefined;
+    await writeToolTrace({
+        toolName,
+        stage: 'start',
+        payload: { params },
+        canvasId,
+    });
+    try {
+        const result = await run();
+        await writeToolTrace({
+            toolName,
+            stage: 'success',
+            payload: { params, result },
+            canvasId,
+        });
+        return result;
+    }
+    catch (error) {
+        await writeToolTrace({
+            toolName,
+            stage: 'error',
+            payload: {
+                params,
+                error: error instanceof Error ? { message: error.message, stack: error.stack } : String(error),
+            },
+            canvasId,
+        });
+        throw error;
+    }
+}
+function isRunnableElement(element) {
+    return (element.type === 130000 ||
+        element.type === 130500 ||
+        element.type === 190000);
+}
+function readElementLabel(element) {
+    const data = element.data;
+    if (typeof data.label === 'string') {
+        return data.label;
+    }
+    if (typeof data.prompt === 'string') {
+        return data.prompt;
+    }
+    if (typeof data.current_model === 'string') {
+        return data.current_model;
+    }
+    if (typeof data.model === 'string') {
+        return data.model;
+    }
+    return '';
+}

package/dist/src/tools/tool-trace.js

@@ -0,0 +1,19 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolvePluginLogDir, localTimestamp } from '../paths.js';
+function sanitizeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_').slice(0, 80) || 'trace';
+}
+export async function writeToolTrace(args) {
+    const timestamp = localTimestamp();
+    const baseDir = resolvePluginLogDir('tool-call-traces');
+    await mkdir(baseDir, { recursive: true });
+    const filePath = path.join(baseDir, `${timestamp}-${sanitizeSegment(args.toolName)}${args.canvasId ? `-${sanitizeSegment(args.canvasId)}` : ''}-${args.stage}.json`);
+    await writeFile(filePath, JSON.stringify({
+        toolName: args.toolName,
+        stage: args.stage,
+        createdAt: new Date().toISOString(),
+        payload: args.payload,
+    }, null, 2), 'utf8');
+    return filePath;
+}