- H3: Client capabilities

- Route: /tools/show-widget

- Headings:

- H2: Use the tool

- H2: Security and storage

- H2: Related

Operator clients may advertise optional capabilities in `connect.params.caps`:

- `tool-events`: accepts structured tool lifecycle events.

- `inline-widgets`: can render hosted inline widget tool results.

Client capabilities describe the connected client, not authorization. Agent tools may declare required capabilities; the Gateway omits those tools unless every requirement appears in the originating client's `caps`. Channel-originated runs have no Gateway client capabilities, so capability-gated tools are unavailable even when tool policy explicitly allows them.

- [Show widget](/tools/show-widget) for self-contained inline SVG and HTML in web chat

summary: "Render self-contained SVG or HTML widgets inline in web chat"

title: "Show widget"

sidebarTitle: "Show widget"

read_when:

- You want an agent to render an interactive result inside web chat

- You need the show_widget input, security, or retention contract

`show_widget` renders a self-contained SVG or HTML fragment inline in the Control UI chat transcript. The bundled Canvas plugin owns the tool and hosts each result as a same-origin Canvas document.

The tool is available only when the originating Gateway client declares the `inline-widgets` capability. The Control UI declares this capability automatically. Channel runs such as Telegram and WhatsApp do not receive `show_widget`.

The agent supplies two required strings:

<ParamField path="title" type="string" required>

Short title shown with the inline preview and in the hosted document title.

</ParamField>

<ParamField path="widget_code" type="string" required>

Self-contained SVG or HTML fragment. Input beginning with `<svg` after trimming is rendered in SVG mode; all other input is treated as an HTML fragment. Maximum length: 262,144 characters.

</ParamField>

The tool result includes a Canvas preview handle, so web chat renders the widget directly from the tool call and restores it after history reload. Transcripts that do not render previews still show the hosted Canvas path.

Widget documents use a restrictive Content Security Policy: inline style and script are allowed, images may use `data:` URLs, and external fetches and resource loads are blocked. Keep all markup, styles, scripts, and image data inside `widget_code`.

The iframe always omits `allow-same-origin`, even when the Control UI's global embed mode is `trusted`, so widget scripts cannot read the parent application origin. The Canvas host also serves widget documents with a `Content-Security-Policy: sandbox allow-scripts` response header, so opening the hosted URL directly still runs the widget in an opaque origin instead of the Control UI origin. Browser sandboxing does not prevent a script from navigating its own iframe; only render widget code you are willing to execute in that isolated frame.

The iframe also follows [`gateway.controlUi.embedSandbox`](/web/control-ui#hosted-embeds). The default `scripts` tier supports interactive widgets while preserving origin isolation.

Canvas retains at most 32 widgets per session (or per agent when no session is available). Creating another widget removes the oldest document in that scope.

- [Control UI hosted embeds](/web/control-ui#hosted-embeds)

- [Canvas plugin](/plugins/reference/canvas)

- [Gateway protocol client capabilities](/gateway/protocol#client-capabilities)

The bundled Canvas plugin also provides [`show_widget`](/tools/show-widget) to render self-contained SVG or HTML directly from a tool call. The browser advertises the `inline-widgets` Gateway capability, and the resulting Canvas document remains available when chat history reloads. Channel-originated runs do not receive this tool.

import {

CanvasToolSchema,

SHOW_WIDGET_REQUIRED_CLIENT_CAPS,

ShowWidgetToolSchema,

} from "./src/tool-schema.js";

function createLazyShowWidgetTool(params: {

config?: OpenClawConfig;

sessionId?: string;

agentId?: string;

}): AnyAgentTool {

const loadTool = createLazyRuntimeModule(() =>

import("./src/widget-tool.js").then(({ createShowWidgetTool }) => createShowWidgetTool(params)),

);

return {

label: "Show Widget",

name: "show_widget",

description:

"Render self-contained SVG or HTML inline in web chat. Use for visual or interactive results; external resources are blocked, so inline all required code and data.",

parameters: ShowWidgetToolSchema,

requiredClientCaps: SHOW_WIDGET_REQUIRED_CLIENT_CAPS,

execute: async (...args: Parameters<AnyAgentTool["execute"]>) =>

await (await loadTool()).execute(...args),

};

api.registerTool(

(ctx) =>

isCanvasHostEnabled(ctx.runtimeConfig ?? ctx.config)

? createLazyShowWidgetTool({

config: ctx.runtimeConfig ?? ctx.config,

sessionId: ctx.sessionId,

agentId: ctx.agentId,

})

: null,

{ name: "show_widget" },

);

"tools": ["canvas", "show_widget"]

retentionScope?: string;

/** Serve the document with a CSP sandbox header so direct opens get an opaque origin. */

cspSandbox?: "scripts";

retentionScope?: string;

cspSandbox?: "scripts";

async function pruneCanvasDocumentsForScope(params: {

documentsDir: string;

retentionScope: string;

maxDocuments: number;

}): Promise<void> {

const entries = await fs.readdir(params.documentsDir, { withFileTypes: true });

const scopedDocuments = (

await Promise.all(

entries

.filter((entry) => entry.isDirectory())

.map(async (entry) => {

try {

const manifest = JSON.parse(

await fs.readFile(

path.join(params.documentsDir, entry.name, "manifest.json"),

"utf8",

),

) as { createdAt?: unknown; retentionScope?: unknown };

if (

manifest.retentionScope !== params.retentionScope ||

typeof manifest.createdAt !== "string"

) {

return null;

}

return { id: entry.name, createdAt: manifest.createdAt };

} catch {

return null;

}

}),

)

).filter((entry): entry is { id: string; createdAt: string } => entry !== null);

const deleteCount = Math.max(0, scopedDocuments.length - params.maxDocuments);

const oldest = scopedDocuments

.toSorted(

(left, right) =>

left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id),

)

.slice(0, deleteCount);

await Promise.all(

oldest.map((entry) =>

fs.rm(path.join(params.documentsDir, entry.id), { recursive: true, force: true }),

),

);

options?: {

stateDir?: string;

workspaceDir?: string;

canvasRootDir?: string;

maxDocumentsPerScope?: number;

},

...(input.retentionScope ? { retentionScope: input.retentionScope } : {}),

...(input.cspSandbox ? { cspSandbox: input.cspSandbox } : {}),

if (input.retentionScope && options?.maxDocumentsPerScope) {

// Bounded transcript widgets cannot grow managed Canvas storage without limit.

await pruneCanvasDocumentsForScope({

documentsDir: resolveCanvasDocumentsDir(options.canvasRootDir, options.stateDir),

retentionScope: input.retentionScope,

maxDocuments: options.maxDocumentsPerScope,

});

}

it("serves sandbox-marked documents with a CSP sandbox header and no live reload", async () => {

const dir = await createCaseDir();

const docDir = path.join(dir, "documents", "widget-1");

await fs.mkdir(docDir, { recursive: true });

await fs.writeFile(

path.join(docDir, "manifest.json"),

JSON.stringify({ id: "widget-1", cspSandbox: "scripts" }),

"utf8",

);

await fs.writeFile(path.join(docDir, "index.html"), "<html><body>widget</body></html>", "utf8");

const plainDir = path.join(dir, "documents", "plain-1");

await fs.mkdir(plainDir, { recursive: true });

await fs.writeFile(

path.join(plainDir, "manifest.json"),

JSON.stringify({ id: "plain-1" }),

"utf8",

);

await fs.writeFile(

path.join(plainDir, "index.html"),

"<html><body>plain</body></html>",

"utf8",

);

const handler = await createTestCanvasHostHandler(dir);

try {

const widget = await captureHandlerResponse(

handler,

`${CANVAS_HOST_PATH}/documents/widget-1/index.html`,

);

expect(widget.status).toBe(200);

// Opaque origin on direct navigation: widget script must not run as the app origin.

expect(widget.headers["content-security-policy"]).toBe("sandbox allow-scripts");

expect(widget.body).toContain("widget");

expect(widget.body).not.toContain(CANVAS_WS_PATH);

const plain = await captureHandlerResponse(

handler,

`${CANVAS_HOST_PATH}/documents/plain-1/index.html`,

);

expect(plain.status).toBe(200);

expect(plain.headers["content-security-policy"]).toBeUndefined();

} finally {

await handler.close();

}

});