clawdbot 2026.1.4-1

package/dist/agents/tool-images.js

@@ -0,0 +1,138 @@
+import { getImageMetadata, resizeToJpeg } from "../media/image-ops.js";
+// Anthropic Messages API limitations (observed in Clawdbot sessions):
+// - Images over ~2000px per side can fail in multi-image requests.
+// - Images over 5MB are rejected by the API.
+//
+// To keep sessions resilient (and avoid "silent" WhatsApp non-replies), we auto-downscale
+// and recompress base64 image blocks when they exceed these limits.
+const MAX_IMAGE_DIMENSION_PX = 2000;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+function isImageBlock(block) {
+    if (!block || typeof block !== "object")
+        return false;
+    const rec = block;
+    return (rec.type === "image" &&
+        typeof rec.data === "string" &&
+        typeof rec.mimeType === "string");
+}
+function isTextBlock(block) {
+    if (!block || typeof block !== "object")
+        return false;
+    const rec = block;
+    return rec.type === "text" && typeof rec.text === "string";
+}
+function inferMimeTypeFromBase64(base64) {
+    const trimmed = base64.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed.startsWith("/9j/"))
+        return "image/jpeg";
+    if (trimmed.startsWith("iVBOR"))
+        return "image/png";
+    if (trimmed.startsWith("R0lGOD"))
+        return "image/gif";
+    return undefined;
+}
+async function resizeImageBase64IfNeeded(params) {
+    const buf = Buffer.from(params.base64, "base64");
+    const meta = await getImageMetadata(buf);
+    const width = meta?.width;
+    const height = meta?.height;
+    const overBytes = buf.byteLength > params.maxBytes;
+    const maxDim = Math.max(width ?? 0, height ?? 0);
+    if (typeof width !== "number" || typeof height !== "number") {
+        if (!overBytes) {
+            return {
+                base64: params.base64,
+                mimeType: params.mimeType,
+                resized: false,
+            };
+        }
+    }
+    else if (!overBytes &&
+        width <= params.maxDimensionPx &&
+        height <= params.maxDimensionPx) {
+        return { base64: params.base64, mimeType: params.mimeType, resized: false };
+    }
+    const qualities = [85, 75, 65, 55, 45, 35];
+    const sideStart = maxDim > 0
+        ? Math.min(params.maxDimensionPx, maxDim)
+        : params.maxDimensionPx;
+    const sideGrid = [sideStart, 1800, 1600, 1400, 1200, 1000, 800]
+        .map((v) => Math.min(params.maxDimensionPx, v))
+        .filter((v, i, arr) => v > 0 && arr.indexOf(v) === i)
+        .sort((a, b) => b - a);
+    let smallest = null;
+    for (const side of sideGrid) {
+        for (const quality of qualities) {
+            const out = await resizeToJpeg({
+                buffer: buf,
+                maxSide: side,
+                quality,
+                withoutEnlargement: true,
+            });
+            if (!smallest || out.byteLength < smallest.size) {
+                smallest = { buffer: out, size: out.byteLength };
+            }
+            if (out.byteLength <= params.maxBytes) {
+                return {
+                    base64: out.toString("base64"),
+                    mimeType: "image/jpeg",
+                    resized: true,
+                };
+            }
+        }
+    }
+    const best = smallest?.buffer ?? buf;
+    const maxMb = (params.maxBytes / (1024 * 1024)).toFixed(0);
+    const gotMb = (best.byteLength / (1024 * 1024)).toFixed(2);
+    throw new Error(`Image could not be reduced below ${maxMb}MB (got ${gotMb}MB)`);
+}
+export async function sanitizeContentBlocksImages(blocks, label, opts = {}) {
+    const maxDimensionPx = Math.max(opts.maxDimensionPx ?? MAX_IMAGE_DIMENSION_PX, 1);
+    const maxBytes = Math.max(opts.maxBytes ?? MAX_IMAGE_BYTES, 1);
+    const out = [];
+    for (const block of blocks) {
+        if (!isImageBlock(block)) {
+            out.push(block);
+            continue;
+        }
+        const data = block.data.trim();
+        if (!data) {
+            out.push({
+                type: "text",
+                text: `[${label}] omitted empty image payload`,
+            });
+            continue;
+        }
+        try {
+            const inferredMimeType = inferMimeTypeFromBase64(data);
+            const mimeType = inferredMimeType ?? block.mimeType;
+            const resized = await resizeImageBase64IfNeeded({
+                base64: data,
+                mimeType,
+                maxDimensionPx,
+                maxBytes,
+            });
+            out.push({
+                ...block,
+                data: resized.base64,
+                mimeType: resized.resized ? resized.mimeType : mimeType,
+            });
+        }
+        catch (err) {
+            out.push({
+                type: "text",
+                text: `[${label}] omitted image payload: ${String(err)}`,
+            });
+        }
+    }
+    return out;
+}
+export async function sanitizeToolResultImages(result, label, opts = {}) {
+    const content = Array.isArray(result.content) ? result.content : [];
+    if (!content.some((b) => isImageBlock(b) || isTextBlock(b)))
+        return result;
+    const next = await sanitizeContentBlocksImages(content, label, opts);
+    return { ...result, content: next };
+}

package/dist/agents/tools/browser-tool.js

@@ -0,0 +1,339 @@
+import { Type } from "@sinclair/typebox";
+import { browserCloseTab, browserFocusTab, browserOpenTab, browserSnapshot, browserStart, browserStatus, browserStop, browserTabs, } from "../../browser/client.js";
+import { browserAct, browserArmDialog, browserArmFileChooser, browserConsoleMessages, browserNavigate, browserPdfSave, browserScreenshotAction, } from "../../browser/client-actions.js";
+import { resolveBrowserConfig } from "../../browser/config.js";
+import { loadConfig } from "../../config/config.js";
+import { imageResultFromFile, jsonResult, readStringParam, } from "./common.js";
+const BrowserActSchema = Type.Union([
+    Type.Object({
+        kind: Type.Literal("click"),
+        ref: Type.String(),
+        targetId: Type.Optional(Type.String()),
+        doubleClick: Type.Optional(Type.Boolean()),
+        button: Type.Optional(Type.String()),
+        modifiers: Type.Optional(Type.Array(Type.String())),
+    }),
+    Type.Object({
+        kind: Type.Literal("type"),
+        ref: Type.String(),
+        text: Type.String(),
+        targetId: Type.Optional(Type.String()),
+        submit: Type.Optional(Type.Boolean()),
+        slowly: Type.Optional(Type.Boolean()),
+    }),
+    Type.Object({
+        kind: Type.Literal("press"),
+        key: Type.String(),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("hover"),
+        ref: Type.String(),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("drag"),
+        startRef: Type.String(),
+        endRef: Type.String(),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("select"),
+        ref: Type.String(),
+        values: Type.Array(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("fill"),
+        fields: Type.Array(Type.Record(Type.String(), Type.Unknown())),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("resize"),
+        width: Type.Number(),
+        height: Type.Number(),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("wait"),
+        timeMs: Type.Optional(Type.Number()),
+        text: Type.Optional(Type.String()),
+        textGone: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("evaluate"),
+        fn: Type.String(),
+        ref: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        kind: Type.Literal("close"),
+        targetId: Type.Optional(Type.String()),
+    }),
+]);
+const BrowserToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("status"),
+        controlUrl: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("start"),
+        controlUrl: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("stop"),
+        controlUrl: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("tabs"),
+        controlUrl: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("open"),
+        controlUrl: Type.Optional(Type.String()),
+        targetUrl: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("focus"),
+        controlUrl: Type.Optional(Type.String()),
+        targetId: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("close"),
+        controlUrl: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("snapshot"),
+        controlUrl: Type.Optional(Type.String()),
+        format: Type.Optional(Type.Union([Type.Literal("aria"), Type.Literal("ai")])),
+        targetId: Type.Optional(Type.String()),
+        limit: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("screenshot"),
+        controlUrl: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+        fullPage: Type.Optional(Type.Boolean()),
+        ref: Type.Optional(Type.String()),
+        element: Type.Optional(Type.String()),
+        type: Type.Optional(Type.Union([Type.Literal("png"), Type.Literal("jpeg")])),
+    }),
+    Type.Object({
+        action: Type.Literal("navigate"),
+        controlUrl: Type.Optional(Type.String()),
+        targetUrl: Type.String(),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("console"),
+        controlUrl: Type.Optional(Type.String()),
+        level: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("pdf"),
+        controlUrl: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("upload"),
+        controlUrl: Type.Optional(Type.String()),
+        paths: Type.Array(Type.String()),
+        ref: Type.Optional(Type.String()),
+        inputRef: Type.Optional(Type.String()),
+        element: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("dialog"),
+        controlUrl: Type.Optional(Type.String()),
+        accept: Type.Boolean(),
+        promptText: Type.Optional(Type.String()),
+        targetId: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("act"),
+        controlUrl: Type.Optional(Type.String()),
+        request: BrowserActSchema,
+    }),
+]);
+function resolveBrowserBaseUrl(controlUrl) {
+    const cfg = loadConfig();
+    const resolved = resolveBrowserConfig(cfg.browser);
+    if (!resolved.enabled && !controlUrl?.trim()) {
+        throw new Error("Browser control is disabled. Set browser.enabled=true in ~/.clawdbot/clawdbot.json.");
+    }
+    const url = controlUrl?.trim() ? controlUrl.trim() : resolved.controlUrl;
+    return url.replace(/\/$/, "");
+}
+export function createBrowserTool(opts) {
+    return {
+        label: "Browser",
+        name: "browser",
+        description: "Control clawd's dedicated browser (status/start/stop/tabs/open/snapshot/screenshot/actions). Use snapshot+act for UI automation. Avoid act:wait by default; use only in exceptional cases when no reliable UI state exists.",
+        parameters: BrowserToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const controlUrl = readStringParam(params, "controlUrl");
+            const baseUrl = resolveBrowserBaseUrl(controlUrl ?? opts?.defaultControlUrl);
+            switch (action) {
+                case "status":
+                    return jsonResult(await browserStatus(baseUrl));
+                case "start":
+                    await browserStart(baseUrl);
+                    return jsonResult(await browserStatus(baseUrl));
+                case "stop":
+                    await browserStop(baseUrl);
+                    return jsonResult(await browserStatus(baseUrl));
+                case "tabs":
+                    return jsonResult({ tabs: await browserTabs(baseUrl) });
+                case "open": {
+                    const targetUrl = readStringParam(params, "targetUrl", {
+                        required: true,
+                    });
+                    return jsonResult(await browserOpenTab(baseUrl, targetUrl));
+                }
+                case "focus": {
+                    const targetId = readStringParam(params, "targetId", {
+                        required: true,
+                    });
+                    await browserFocusTab(baseUrl, targetId);
+                    return jsonResult({ ok: true });
+                }
+                case "close": {
+                    const targetId = readStringParam(params, "targetId");
+                    if (targetId)
+                        await browserCloseTab(baseUrl, targetId);
+                    else
+                        await browserAct(baseUrl, { kind: "close" });
+                    return jsonResult({ ok: true });
+                }
+                case "snapshot": {
+                    const format = params.format === "ai" || params.format === "aria"
+                        ? params.format
+                        : "ai";
+                    const targetId = typeof params.targetId === "string"
+                        ? params.targetId.trim()
+                        : undefined;
+                    const limit = typeof params.limit === "number" && Number.isFinite(params.limit)
+                        ? params.limit
+                        : undefined;
+                    const snapshot = await browserSnapshot(baseUrl, {
+                        format,
+                        targetId,
+                        limit,
+                    });
+                    if (snapshot.format === "ai") {
+                        return {
+                            content: [{ type: "text", text: snapshot.snapshot }],
+                            details: snapshot,
+                        };
+                    }
+                    return jsonResult(snapshot);
+                }
+                case "screenshot": {
+                    const targetId = readStringParam(params, "targetId");
+                    const fullPage = Boolean(params.fullPage);
+                    const ref = readStringParam(params, "ref");
+                    const element = readStringParam(params, "element");
+                    const type = params.type === "jpeg" ? "jpeg" : "png";
+                    const result = await browserScreenshotAction(baseUrl, {
+                        targetId,
+                        fullPage,
+                        ref,
+                        element,
+                        type,
+                    });
+                    return await imageResultFromFile({
+                        label: "browser:screenshot",
+                        path: result.path,
+                        details: result,
+                    });
+                }
+                case "navigate": {
+                    const targetUrl = readStringParam(params, "targetUrl", {
+                        required: true,
+                    });
+                    const targetId = readStringParam(params, "targetId");
+                    return jsonResult(await browserNavigate(baseUrl, { url: targetUrl, targetId }));
+                }
+                case "console": {
+                    const level = typeof params.level === "string" ? params.level.trim() : undefined;
+                    const targetId = typeof params.targetId === "string"
+                        ? params.targetId.trim()
+                        : undefined;
+                    return jsonResult(await browserConsoleMessages(baseUrl, { level, targetId }));
+                }
+                case "pdf": {
+                    const targetId = typeof params.targetId === "string"
+                        ? params.targetId.trim()
+                        : undefined;
+                    const result = await browserPdfSave(baseUrl, { targetId });
+                    return {
+                        content: [{ type: "text", text: `FILE:${result.path}` }],
+                        details: result,
+                    };
+                }
+                case "upload": {
+                    const paths = Array.isArray(params.paths)
+                        ? params.paths.map((p) => String(p))
+                        : [];
+                    if (paths.length === 0)
+                        throw new Error("paths required");
+                    const ref = readStringParam(params, "ref");
+                    const inputRef = readStringParam(params, "inputRef");
+                    const element = readStringParam(params, "element");
+                    const targetId = typeof params.targetId === "string"
+                        ? params.targetId.trim()
+                        : undefined;
+                    const timeoutMs = typeof params.timeoutMs === "number" &&
+                        Number.isFinite(params.timeoutMs)
+                        ? params.timeoutMs
+                        : undefined;
+                    return jsonResult(await browserArmFileChooser(baseUrl, {
+                        paths,
+                        ref,
+                        inputRef,
+                        element,
+                        targetId,
+                        timeoutMs,
+                    }));
+                }
+                case "dialog": {
+                    const accept = Boolean(params.accept);
+                    const promptText = typeof params.promptText === "string"
+                        ? params.promptText
+                        : undefined;
+                    const targetId = typeof params.targetId === "string"
+                        ? params.targetId.trim()
+                        : undefined;
+                    const timeoutMs = typeof params.timeoutMs === "number" &&
+                        Number.isFinite(params.timeoutMs)
+                        ? params.timeoutMs
+                        : undefined;
+                    return jsonResult(await browserArmDialog(baseUrl, {
+                        accept,
+                        promptText,
+                        targetId,
+                        timeoutMs,
+                    }));
+                }
+                case "act": {
+                    const request = params.request;
+                    if (!request || typeof request !== "object") {
+                        throw new Error("request required");
+                    }
+                    const result = await browserAct(baseUrl, request);
+                    return jsonResult(result);
+                }
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        },
+    };
+}

package/dist/agents/tools/canvas-tool.js

@@ -0,0 +1,193 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import { Type } from "@sinclair/typebox";
+import { writeBase64ToFile } from "../../cli/nodes-camera.js";
+import { canvasSnapshotTempPath, parseCanvasSnapshotPayload, } from "../../cli/nodes-canvas.js";
+import { imageMimeFromFormat } from "../../media/mime.js";
+import { imageResult, jsonResult, readStringParam, } from "./common.js";
+import { callGatewayTool } from "./gateway.js";
+import { resolveNodeId } from "./nodes-utils.js";
+const CanvasToolSchema = Type.Union([
+    Type.Object({
+        action: Type.Literal("present"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+        target: Type.Optional(Type.String()),
+        x: Type.Optional(Type.Number()),
+        y: Type.Optional(Type.Number()),
+        width: Type.Optional(Type.Number()),
+        height: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("hide"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("navigate"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+        url: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("eval"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+        javaScript: Type.String(),
+    }),
+    Type.Object({
+        action: Type.Literal("snapshot"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+        format: Type.Optional(Type.Union([
+            Type.Literal("png"),
+            Type.Literal("jpg"),
+            Type.Literal("jpeg"),
+        ])),
+        maxWidth: Type.Optional(Type.Number()),
+        quality: Type.Optional(Type.Number()),
+        delayMs: Type.Optional(Type.Number()),
+    }),
+    Type.Object({
+        action: Type.Literal("a2ui_push"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+        jsonl: Type.Optional(Type.String()),
+        jsonlPath: Type.Optional(Type.String()),
+    }),
+    Type.Object({
+        action: Type.Literal("a2ui_reset"),
+        gatewayUrl: Type.Optional(Type.String()),
+        gatewayToken: Type.Optional(Type.String()),
+        timeoutMs: Type.Optional(Type.Number()),
+        node: Type.Optional(Type.String()),
+    }),
+]);
+export function createCanvasTool() {
+    return {
+        label: "Canvas",
+        name: "canvas",
+        description: "Control node canvases (present/hide/navigate/eval/snapshot/A2UI). Use snapshot to capture the rendered UI.",
+        parameters: CanvasToolSchema,
+        execute: async (_toolCallId, args) => {
+            const params = args;
+            const action = readStringParam(params, "action", { required: true });
+            const gatewayOpts = {
+                gatewayUrl: readStringParam(params, "gatewayUrl", { trim: false }),
+                gatewayToken: readStringParam(params, "gatewayToken", { trim: false }),
+                timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : undefined,
+            };
+            const nodeId = await resolveNodeId(gatewayOpts, readStringParam(params, "node", { trim: true }), true);
+            const invoke = async (command, invokeParams) => await callGatewayTool("node.invoke", gatewayOpts, {
+                nodeId,
+                command,
+                params: invokeParams,
+                idempotencyKey: crypto.randomUUID(),
+            });
+            switch (action) {
+                case "present": {
+                    const placement = {
+                        x: typeof params.x === "number" ? params.x : undefined,
+                        y: typeof params.y === "number" ? params.y : undefined,
+                        width: typeof params.width === "number" ? params.width : undefined,
+                        height: typeof params.height === "number" ? params.height : undefined,
+                    };
+                    const invokeParams = {};
+                    if (typeof params.target === "string" && params.target.trim()) {
+                        invokeParams.url = params.target.trim();
+                    }
+                    if (Number.isFinite(placement.x) ||
+                        Number.isFinite(placement.y) ||
+                        Number.isFinite(placement.width) ||
+                        Number.isFinite(placement.height)) {
+                        invokeParams.placement = placement;
+                    }
+                    await invoke("canvas.present", invokeParams);
+                    return jsonResult({ ok: true });
+                }
+                case "hide":
+                    await invoke("canvas.hide", undefined);
+                    return jsonResult({ ok: true });
+                case "navigate": {
+                    const url = readStringParam(params, "url", { required: true });
+                    await invoke("canvas.navigate", { url });
+                    return jsonResult({ ok: true });
+                }
+                case "eval": {
+                    const javaScript = readStringParam(params, "javaScript", {
+                        required: true,
+                    });
+                    const raw = (await invoke("canvas.eval", { javaScript }));
+                    const result = raw?.payload?.result;
+                    if (result) {
+                        return {
+                            content: [{ type: "text", text: result }],
+                            details: { result },
+                        };
+                    }
+                    return jsonResult({ ok: true });
+                }
+                case "snapshot": {
+                    const formatRaw = typeof params.format === "string"
+                        ? params.format.toLowerCase()
+                        : "png";
+                    const format = formatRaw === "jpg" || formatRaw === "jpeg" ? "jpeg" : "png";
+                    const maxWidth = typeof params.maxWidth === "number" &&
+                        Number.isFinite(params.maxWidth)
+                        ? params.maxWidth
+                        : undefined;
+                    const quality = typeof params.quality === "number" &&
+                        Number.isFinite(params.quality)
+                        ? params.quality
+                        : undefined;
+                    const raw = (await invoke("canvas.snapshot", {
+                        format,
+                        maxWidth,
+                        quality,
+                    }));
+                    const payload = parseCanvasSnapshotPayload(raw?.payload);
+                    const filePath = canvasSnapshotTempPath({
+                        ext: payload.format === "jpeg" ? "jpg" : payload.format,
+                    });
+                    await writeBase64ToFile(filePath, payload.base64);
+                    const mimeType = imageMimeFromFormat(payload.format) ?? "image/png";
+                    return await imageResult({
+                        label: "canvas:snapshot",
+                        path: filePath,
+                        base64: payload.base64,
+                        mimeType,
+                        details: { format: payload.format },
+                    });
+                }
+                case "a2ui_push": {
+                    const jsonl = typeof params.jsonl === "string" && params.jsonl.trim()
+                        ? params.jsonl
+                        : typeof params.jsonlPath === "string" && params.jsonlPath.trim()
+                            ? await fs.readFile(params.jsonlPath.trim(), "utf8")
+                            : "";
+                    if (!jsonl.trim())
+                        throw new Error("jsonl or jsonlPath required");
+                    await invoke("canvas.a2ui.pushJSONL", { jsonl });
+                    return jsonResult({ ok: true });
+                }
+                case "a2ui_reset":
+                    await invoke("canvas.a2ui.reset", undefined);
+                    return jsonResult({ ok: true });
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+        },
+    };
+}