Copy destructiveHint to consequentialHint

js/README.md

@@ -245,7 +245,9 @@ point of view. A full page load ends the call before it can return.
 | `xwebmcp` | `registerTool(tool, { signal })`, `refresh()`, `getModelContext()`, `availableToolNames()`, `subscribe(listener)`; no React |
 
 `useWebMCPTool({ name, description, inputSchema?, outputSchema?, annotations?, title?, execute, enabled? })`
-takes the fields of a WebMCP tool plus `enabled`.
+takes the fields of a WebMCP tool plus `enabled`. Chrome reads `consequentialHint` rather than
+MCP's `destructiveHint`; when only the latter is set it is copied over, so a destructive tool is
+marked as needing confirmation.
 
 `useWebMCPRoute({ path, description, enabled? })`.
 

js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xwebmcp",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Register WebMCP tools from React and Next.js components, with distributed get_page_context and navigate_to_page tools.",
   "license": "MIT",
   "repository": {

js/src/index.ts

@@ -6,6 +6,11 @@ export interface ToolAnnotations {
   idempotentHint?: boolean;
   openWorldHint?: boolean;
   untrustedContentHint?: boolean;
+  /**
+   * WebMCP's name for an action with effects the user would want to confirm.
+   * Defaults to `destructiveHint`, so MCP-style annotations carry over.
+   */
+  consequentialHint?: boolean;
 }
 
 export interface WebMCPTool<Input = any, Output = unknown> {
@@ -121,6 +126,11 @@ function notify() {
   for (const listener of listeners) listener();
 }
 
+function withConsequentialHint(annotations: ToolAnnotations): ToolAnnotations {
+  if (annotations.consequentialHint !== undefined || annotations.destructiveHint === undefined) return annotations;
+  return { ...annotations, consequentialHint: annotations.destructiveHint };
+}
+
 function sync(name: string) {
   const ctx = context();
   if (!ctx) return;
@@ -134,14 +144,19 @@ function sync(name: string) {
   if (top) {
     const controller = new AbortController();
     active.set(name, { tool: top, controller });
-    const { execute, ...definition } = top;
+    const { execute, annotations, ...definition } = top;
     // Deferred so that replacing a registration within one task only
     // registers the final one with the browser.
     Promise.resolve()
       .then(() => {
         if (controller.signal.aborted) return;
         return ctx.registerTool(
-          { inputSchema: { type: 'object', properties: {} }, ...definition, execute },
+          {
+            inputSchema: { type: 'object', properties: {} },
+            ...definition,
+            ...(annotations ? { annotations: withConsequentialHint(annotations) } : {}),
+            execute,
+          },
           { signal: controller.signal },
         );
       })

js/test/core.test.ts

@@ -114,6 +114,24 @@ describe('with WebMCP', () => {
     expect(ctx.tools.has('a')).toBe(true);
   });
 
+  it('derives consequentialHint from destructiveHint', async () => {
+    const ctx = installFakeModelContext();
+    core.registerTool({ ...tool('a'), annotations: { destructiveHint: true } }, { signal: new AbortController().signal });
+    core.registerTool(
+      { ...tool('b'), annotations: { destructiveHint: true, consequentialHint: false } },
+      { signal: new AbortController().signal },
+    );
+    await flush();
+    expect((ctx.tools.get('a') as { annotations?: object }).annotations).toEqual({
+      destructiveHint: true,
+      consequentialHint: true,
+    });
+    expect((ctx.tools.get('b') as { annotations?: object }).annotations).toEqual({
+      destructiveHint: true,
+      consequentialHint: false,
+    });
+  });
+
   it('lists tools registered outside this package', async () => {
     const ctx = installFakeModelContext();
     ctx.registerTool({ ...tool('native'), inputSchema: {} }, { signal: new AbortController().signal });