Add SDK canvas runtime support

[jmoseley]

What changed

• Adds the Node extension canvas surface (createCanvas, canvas declarations, handler contexts, errors, and exports) and wires session create/resume to send canvases, requestCanvasRenderer, requestExtensions, and stable extensionInfo.
• Adds focused Rust canvas support with Canvas, CanvasHandler, direct canvas.open|focus|reload|close|action.invoke provider callback routing, and host APIs under session.canvas() for discover, list_open, open, focus, reload, close, and invoke_action.
• Aligns the SDK contracts with the runtime branch: displayName is required for canvas declarations, session.canvas.listOpen is a real RPC, resume consumes openCanvases, and capabilities.ui.canvases is boolean.
• Adds ExtensionInfo { source, name } / extensionInfo so consumers can opt into stable agent-facing extension IDs like github-app:<provider-name> instead of reconnect-specific fallback IDs.

Notes for reviewers

The Rust implementation is additive and keeps the existing separate permission/user-input/tool handler model. Canvas provider callbacks are routed through a focused per-session canvas registry rather than a unified session handler refactor.

Validation

• cd nodejs && npm run typecheck
• cd nodejs && npm run lint (existing warnings only)
• cd nodejs && npx vitest run test/client.test.ts test/extension.test.ts
• cd rust && cargo +nightly-2026-04-14 fmt --check
• cd rust && cargo clippy --all-features --all-targets -- -D warnings
• cd rust && cargo test --all-features

[Copilot]

Pull request overview

This PR adds cross-SDK “canvas runtime” support, enabling SDK consumers to declare canvases, receive direct provider callbacks (canvas.*), and use host-side session.canvas.* RPCs with stable extension identity (extensionInfo)—without requiring the larger handler refactor from the prototype branch.

Changes:

• Rust: Introduces a new canvas module (declarations, handler traits, dispatch, host RPC types) and wires SessionConfig / ResumeSessionConfig to serialize canvas-related fields on session.create / session.resume.
• Rust: Adds Session::canvas() host API and updates the session event loop/router to handle direct provider callback requests (canvas.open|focus|reload|close|action.invoke).
• Node.js: Adds a canvas surface (createCanvas, types, dispatch), forwards canvas declarations + request flags + extensionInfo on session create/resume, and routes direct canvas.* JSON-RPC requests to registered canvases with tests.

Show a summary per file

File	Description
rust/tests/session_test.rs	Adds coverage for Rust canvas wire fields, provider dispatch routing, and SessionCanvas host API behavior.
rust/tests/e2e/elicitation.rs	Updates capability struct test to include the new ui.canvases field.
rust/src/wire.rs	Extends session create/resume wire payloads with canvases, request flags, and extension_info.
rust/src/types.rs	Adds ExtensionInfo, canvas config fields on session configs, resume result open-canvas capture, and UiCapabilities.canvases.
rust/src/session.rs	Adds SessionCanvas host API + open-canvas tracking and routes canvas.* provider callbacks through a per-session registry.
rust/src/router.rs	Adds debug logging when routing requests to a registered session.
rust/src/lib.rs	Exposes the new canvas module publicly.
rust/src/jsonrpc.rs	Adds debug logging for incoming JSON-RPC requests from the runtime.
rust/src/canvas.rs	New Rust canvas module: declarations, handler traits, registry + dispatch, request/response types, and unit tests.
nodejs/test/extension.test.ts	Verifies createCanvas is exported from the extension surface.
nodejs/test/client.test.ts	Adds tests for forwarding canvas fields on create/resume and for direct provider dispatch behavior.
nodejs/src/types.ts	Adds SessionCapabilities.ui.canvases, introduces ExtensionInfo, and extends session configs with canvas fields.
nodejs/src/session.ts	Adds per-session canvas registration and lookup to support direct dispatch routing.
nodejs/src/index.ts	Exports canvas APIs/types and ExtensionInfo from the main entrypoint.
nodejs/src/extension.ts	Exports canvas APIs/types and ExtensionInfo from the extension surface.
nodejs/src/client.ts	Forwards canvas fields on create/resume and registers handlers for direct canvas.* provider callbacks.
nodejs/src/canvas.ts	New Node canvas module: canvas declaration/types, createCanvas, and provider request dispatch helper.

Copilot's findings

• Files reviewed: 17/17 changed files
• Comments generated: 5

[github-actions]

Cross-SDK Consistency Review

This PR adds canvas support to the Node.js and Rust SDKs. The following new surface area is not yet present in the Python, Go, or .NET SDKs:

Missing from Python, Go, and .NET

1. SessionConfig / ResumeSessionConfig fields

The following new parameters are added to Node.js SessionConfig/ResumeSessionConfig but are absent in all three other SDKs:

Node.js (camelCase)	Python (snake_case)	Go (PascalCase)	.NET (PascalCase)
canvases?: Canvas[]	canvases	Canvases	Canvases
requestCanvasRenderer?: boolean	request_canvas_renderer	RequestCanvasRenderer	RequestCanvasRenderer
requestExtensions?: boolean	request_extensions	RequestExtensions	RequestExtensions
extensionInfo?: ExtensionInfo	extension_info	ExtensionInfo	ExtensionInfo

2. ExtensionInfo type

Node.js and Rust both define ExtensionInfo { source, name } for stable agent-facing extension IDs. Python, Go, and .NET have no equivalent type.

3. Canvas provider callback handling

Node.js registers server-side handlers for canvas.open, canvas.close, and canvas.action.invoke RPC requests. These are not wired in Python, Go, or .NET.

4. Session-level canvas host APIs

Rust exposes session.canvas() with host-side methods: discover, list_open, open, close, invoke_action. Python, Go, and .NET have no equivalent.

5. SessionCapabilities.ui.canvases

Node.js now uses a typed SessionCapabilities that includes capabilities.ui.canvases: boolean. This capability flag is absent from the other SDK capability models.

---

Suggestion

If canvas support is intended to be a first-class SDK feature (vs. a Node.js/Rust-only prototype), I'd suggest tracking follow-up issues to bring Python, Go, and .NET into parity. At minimum, the SessionConfig field additions (canvases, extensionInfo, requestCanvasRenderer, requestExtensions) would ensure those SDKs can at least declare canvas interest when creating sessions, even before full provider-callback and host-API support is added.

If this is intentionally a staged rollout (Node.js + Rust first), that's a perfectly reasonable approach — just worth noting in the PR description so downstream consumers know which SDKs support canvas today.

Generated by SDK Consistency Review Agent for issue #1401 · ● 7M · ◷