@agent-surface/webmcp 0.24.0 → 0.25.0

package/README.md

@@ -2,7 +2,7 @@
 
 > **Experimental.** The WebMCP (`navigator.modelContext`) surface area, permission model, and lifecycle are unstable; this adapter tracks them and absorbs the drift so nothing WebMCP-shaped leaks into `@agent-surface/core`. The application model stays in agent-surface — WebMCP is strictly transport/discovery.
 
-WebMCP transport adapter for [agent-surface](https://github.com/Wiseair-srl/agent-surface): one wire-named tool per **available** capability, re-provided on every `surface-changed`. Unavailable capabilities are not registered (WebMCP has no disabled state today — the availability reason is lost on this transport; accepted limitation). The user agent is treated as the least-trusted consumer: scope the adapter and keep two-phase confirmations.
+WebMCP transport adapter for [agent-surface](https://github.com/Wiseair-srl/agent-surface): one wire-named tool per **available** capability, reconciled on every `surface-changed` (incremental `registerTool`/`unregisterTool` when the browser has them, a full `provideContext` otherwise). Unavailable capabilities are not registered (WebMCP has no disabled state today, so the availability reason is lost on this transport; accepted limitation). Observations and read-only effects carry `annotations.readOnlyHint`. The user agent is treated as the least-trusted consumer: scope the adapter and keep confirmations governed by the registry.
 
 Docs: https://agent-surface.dev
 
@@ -23,7 +23,31 @@ const adapter = createWebMcpAdapter({
 adapter.start({ registry, consumer: { id: "browser-agent", kind: "webmcp" } });
 ```
 
-If `navigator.modelContext` is absent, `start()` resolves and does nothing (feature-detect, never polyfill). Capability errors ride in tool content with `code`/`retry`/`details` preserved — never protocol-level errors.
+If `navigator.modelContext` is absent, `start()` resolves and does nothing (feature-detect, never polyfill). Capability errors ride in tool content with `code`/`retry`/`details` preserved, never as protocol-level errors. `stop()` withdraws every tool the adapter exposed and can run repeatedly.
+
+Confirmations are two-phase by default. To confirm in page within one tool call, pass host UI; it runs through WebMCP's `client.requestUserInteraction` and the registry still decides:
+
+```ts
+createWebMcpAdapter({
+  confirm: (request) => showConfirmDialog(request.summary),
+});
+```
+
+Only the imperative API is used. The declarative API (DOM forms as tools) is a non-goal: capabilities must be compiler-authorized, not derived from rendered DOM.
+
+## Targeted WebMCP revision
+
+The W3C Web Machine Learning CG draft ([webmachinelearning/webmcp](https://github.com/webmachinelearning/webmcp)) as exposed by the Chrome early preview (Chrome 146+, `chrome://flags/#enable-webmcp-testing`). Assumed surface:
+
+| Member | Use |
+|---|---|
+| `modelContext.provideContext({ tools })` | required; fallback full-set replacement |
+| `modelContext.clearContext()` | optional; `stop()` on the fallback path |
+| `modelContext.registerTool(tool)` / `unregisterTool(name)` | optional, feature-detected together |
+| tool `{ name, description, inputSchema, annotations?: { readOnlyHint? }, execute(input, client) }` | tool shape |
+| `client.requestUserInteraction(callback)` | optional; in-page confirmation |
+
+Keep this table in sync with [docs/09](https://github.com/Wiseair-srl/agent-surface/blob/main/docs/09-adapters.md#targeted-webmcp-revision).
 
 Full specification: [docs/09](https://github.com/Wiseair-srl/agent-surface/blob/main/docs/09-adapters.md).
 

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { AgentSurfaceRegistry, AgentConsumer, SnapshotContext, AgentCapabilityDescriptorUnion, JsonSchema, JsonValue } from '@agent-surface/core';
+import { AgentSurfaceRegistry, AgentConsumer, SnapshotContext, AgentCapabilityDescriptorUnion, PendingConfirmation, JsonSchema, JsonValue } from '@agent-surface/core';
 
 interface AdapterHost {
     registry: AgentSurfaceRegistry;
@@ -11,11 +11,21 @@ interface AgentSurfaceAdapter {
     start(host: AdapterHost): void | Promise<void>;
     stop(): void | Promise<void>;
 }
+interface WebMcpToolAnnotations {
+    /** The tool does not change state; a browser agent may skip its approval prompt. */
+    readOnlyHint?: boolean;
+}
+/** The per-call client WebMCP passes to `execute`. */
+interface WebMcpClient {
+    /** Pauses the tool call to run in-page UI; resolves with the callback's value. */
+    requestUserInteraction?<T>(callback: () => Promise<T>): Promise<T>;
+}
 interface WebMcpToolInit {
     name: string;
     description: string;
     inputSchema: JsonSchema;
-    execute(input: JsonValue): Promise<WebMcpToolResult>;
+    annotations?: WebMcpToolAnnotations;
+    execute(input: JsonValue, client?: WebMcpClient): Promise<WebMcpToolResult>;
 }
 interface WebMcpToolResult {
     content: Array<{
@@ -25,9 +35,14 @@ interface WebMcpToolResult {
     isError?: boolean;
 }
 interface WebMcpModelContext {
+    /** Replaces the whole tool set. Fallback when the incremental API is absent. */
     provideContext(context: {
         tools: WebMcpToolInit[];
     }): void;
+    /** Removes every tool provided through provideContext. */
+    clearContext?(): void;
+    registerTool?(tool: WebMcpToolInit): unknown;
+    unregisterTool?(name: string): void;
 }
 interface CreateWebMcpAdapterOptions {
     snapshotContext?: Omit<SnapshotContext, "consumer">;
@@ -38,16 +53,27 @@ interface CreateWebMcpAdapterOptions {
     exposeCapability?: (descriptor: AgentCapabilityDescriptorUnion) => {
         description?: string;
     } | null | undefined;
+    /**
+     * Opt-in in-page confirmation. When a call returns CONFIRMATION_REQUIRED and
+     * the WebMCP client supports `requestUserInteraction`, this host UI runs
+     * inside it; the answer resolves the registry's pending confirmation and the
+     * call is retried once, so the agent sees one final result. The registry
+     * stays the confirmation authority. Absent (or no client support) ⇒
+     * unchanged two-phase behavior.
+     */
+    confirm?: (request: PendingConfirmation, client: WebMcpClient) => Promise<boolean> | boolean;
     /** Test seam: defaults to (navigator as any).modelContext. */
     modelContext?: WebMcpModelContext;
 }
 /**
  * Maps the registry onto `navigator.modelContext`, treating WebMCP strictly
  * as transport/discovery: one wire-named tool per AVAILABLE capability,
- * re-provided on every surface-changed; unavailable capabilities are not
- * registered (WebMCP has no disabled state today — accepted limitation);
- * confirmations stay two-phase; absent modelContext ⇒ start() does nothing.
+ * reconciled on every surface-changed (incremental registerTool/unregisterTool
+ * when the browser supports it, full provideContext otherwise); unavailable
+ * capabilities are not registered (WebMCP has no disabled state today —
+ * accepted limitation); confirmations stay two-phase unless `confirm` is set;
+ * absent modelContext ⇒ start() does nothing; stop() withdraws every tool.
  */
 declare function createWebMcpAdapter(options?: CreateWebMcpAdapterOptions): AgentSurfaceAdapter;
 
-export { type AdapterHost, type AgentSurfaceAdapter, type CreateWebMcpAdapterOptions, type WebMcpModelContext, type WebMcpToolInit, type WebMcpToolResult, createWebMcpAdapter };
+export { type AdapterHost, type AgentSurfaceAdapter, type CreateWebMcpAdapterOptions, type WebMcpClient, type WebMcpModelContext, type WebMcpToolAnnotations, type WebMcpToolInit, type WebMcpToolResult, createWebMcpAdapter };

package/dist/index.js

@@ -5,100 +5,196 @@ function randomInvocationId() {
 }
 
 // src/index.ts
+var READ_ONLY_EFFECTS = /* @__PURE__ */ new Set(["read", "server-query"]);
 function createWebMcpAdapter(options) {
-  let unsubscribe;
+  let session;
   return {
     name: "webmcp",
     start(host) {
+      if (session) return;
       const modelContext = options?.modelContext ?? globalThis.navigator?.modelContext;
       if (!modelContext) return;
-      const provide = () => {
+      const incremental = typeof modelContext.registerTool === "function" && typeof modelContext.unregisterTool === "function";
+      const state = {
+        modelContext,
+        incremental,
+        exposed: /* @__PURE__ */ new Map(),
+        unsubscribe: () => {
+        },
+        active: true
+      };
+      const invoke = (target, invocationId, input, confirmationId) => host.registry.invoke(
+        {
+          invocationId,
+          capabilityId: target.capabilityId,
+          registrationId: target.registrationId,
+          surfaceVersion: target.surfaceVersion,
+          // Forwarded as given (like the core toolset): dropping `{}` made
+          // zero-argument actions fail INVALID_INPUT. Observations ignore input.
+          ...input !== void 0 ? { input } : {},
+          ...confirmationId !== void 0 ? { confirmationId } : {}
+        },
+        { consumer: host.consumer }
+      );
+      const toTool = (desired, target) => ({
+        name: desired.name,
+        description: desired.description,
+        inputSchema: desired.inputSchema,
+        ...desired.readOnly ? { annotations: { readOnlyHint: true } } : {},
+        execute: async (input, client) => {
+          const invocationId = randomInvocationId();
+          let result = await invoke(target, invocationId, input);
+          const confirmationId = result.status === "error" && result.error.code === "CONFIRMATION_REQUIRED" ? result.error.details?.confirmationId : void 0;
+          if (options?.confirm && typeof confirmationId === "string" && typeof client?.requestUserInteraction === "function" && state.active) {
+            const pending = host.registry.confirmations.pending().find((record) => record.confirmationId === confirmationId);
+            if (pending) {
+              const confirm = options.confirm;
+              let approved;
+              try {
+                approved = await client.requestUserInteraction(async () => confirm(pending, client)) === true;
+              } catch {
+                approved = void 0;
+              }
+              if (approved !== void 0 && state.active) {
+                host.registry.confirmations.resolve(
+                  confirmationId,
+                  approved ? { approved: true } : { approved: false, reason: "Declined in page" }
+                );
+                result = await invoke(target, invocationId, input, confirmationId);
+              }
+            }
+          }
+          if (result.status === "ok") {
+            return {
+              content: [{ type: "text", text: JSON.stringify(result.output ?? null) }]
+            };
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify(result.error) }],
+            isError: true
+          };
+        }
+      });
+      const desiredTools = () => {
         const snapshot = host.registry.snapshot({
           consumer: host.consumer,
           ...options?.snapshotContext ?? host.snapshotContext ?? {},
           includeUnavailable: false
         });
         const tools = [];
-        const toTool = (descriptor, capabilityId, registrationId, inputSchema, description) => ({
-          name: encodeWireName(capabilityId),
-          description,
-          inputSchema,
-          execute: async (input) => {
-            const result = await host.registry.invoke(
-              {
-                invocationId: randomInvocationId(),
-                capabilityId,
-                registrationId,
-                surfaceVersion: snapshot.surfaceVersion,
-                ...input !== void 0 && Object.keys(input).length > 0 ? { input } : {}
-              },
-              { consumer: host.consumer }
-            );
-            if (result.status === "ok") {
-              return {
-                content: [{ type: "text", text: JSON.stringify(result.output ?? null) }]
-              };
-            }
-            return {
-              content: [{ type: "text", text: JSON.stringify(result.error) }],
-              isError: true
-            };
-          }
-        });
+        const add = (descriptor, capabilityId, registrationId, inputSchema, defaultDescription, readOnly) => {
+          if (!descriptor.available) return;
+          const curated = options?.exposeCapability?.(descriptor);
+          if (options?.exposeCapability && curated === null) return;
+          tools.push({
+            name: encodeWireName(capabilityId),
+            capabilityId,
+            registrationId,
+            inputSchema,
+            description: curated?.description ?? defaultDescription,
+            // Derived from the declared kind/effect only; curation cannot widen it.
+            readOnly
+          });
+        };
         for (const component of snapshot.components) {
           for (const obs of component.observations) {
-            if (!obs.available) continue;
-            const curated = options?.exposeCapability?.(obs);
-            if (options?.exposeCapability && curated === null) continue;
-            tools.push(
-              toTool(
-                obs,
-                obs.capabilityId,
-                component.registrationId,
-                { type: "object", properties: {}, additionalProperties: false },
-                curated?.description ?? `[view \xB7 read] ${obs.description}`
-              )
+            add(
+              obs,
+              obs.capabilityId,
+              component.registrationId,
+              { type: "object", properties: {}, additionalProperties: false },
+              `[view \xB7 read] ${obs.description}`,
+              true
             );
           }
           for (const act of component.actions) {
-            if (!act.available) continue;
-            const curated = options?.exposeCapability?.(act);
-            if (options?.exposeCapability && curated === null) continue;
-            tools.push(
-              toTool(
-                act,
-                act.capabilityId,
-                component.registrationId,
-                act.inputSchema,
-                curated?.description ?? `[view \xB7 ${act.effect}] ${act.description}`
-              )
+            add(
+              act,
+              act.capabilityId,
+              component.registrationId,
+              act.inputSchema,
+              `[view \xB7 ${act.effect}] ${act.description}`,
+              READ_ONLY_EFFECTS.has(act.effect)
             );
           }
         }
         for (const proc of snapshot.procedures) {
-          if (!proc.available) continue;
-          const curated = options?.exposeCapability?.(proc);
-          if (options?.exposeCapability && curated === null) continue;
-          tools.push(
-            toTool(
-              proc,
-              proc.procedureId,
-              proc.registrationId,
-              proc.inputSchema,
-              curated?.description ?? `[domain \xB7 ${proc.effect}${proc.confirmation === "required" ? " \xB7 requires confirmation" : ""}] ${proc.description}`
-            )
+          add(
+            proc,
+            proc.procedureId,
+            proc.registrationId,
+            proc.inputSchema,
+            `[domain \xB7 ${proc.effect}${proc.confirmation === "required" ? " \xB7 requires confirmation" : ""}] ${proc.description}`,
+            READ_ONLY_EFFECTS.has(proc.effect)
           );
         }
-        modelContext.provideContext({ tools });
+        return { surfaceVersion: snapshot.surfaceVersion, tools };
+      };
+      const reconcile = () => {
+        if (!state.active) return;
+        const { surfaceVersion, tools } = desiredTools();
+        const next = /* @__PURE__ */ new Map();
+        const toRegister = [];
+        for (const desired of tools) {
+          const signature = JSON.stringify([
+            desired.description,
+            desired.inputSchema,
+            desired.registrationId,
+            desired.capabilityId,
+            desired.readOnly
+          ]);
+          const current = state.exposed.get(desired.name);
+          if (current && current.signature === signature) {
+            current.target.surfaceVersion = surfaceVersion;
+            next.set(desired.name, current);
+            continue;
+          }
+          const target = {
+            capabilityId: desired.capabilityId,
+            registrationId: desired.registrationId,
+            surfaceVersion
+          };
+          const tool = toTool(desired, target);
+          next.set(desired.name, { tool, target, signature });
+          toRegister.push(tool);
+        }
+        if (state.incremental) {
+          for (const [name, current] of state.exposed) {
+            const replacement = next.get(name);
+            if (replacement !== current) modelContext.unregisterTool(name);
+          }
+          for (const tool of toRegister) modelContext.registerTool(tool);
+        } else {
+          modelContext.provideContext({ tools: [...next.values()].map((entry) => entry.tool) });
+        }
+        state.exposed = next;
       };
-      provide();
-      unsubscribe = host.registry.subscribe((event) => {
-        if (event.type === "surface-changed") provide();
+      session = state;
+      reconcile();
+      state.unsubscribe = host.registry.subscribe((event) => {
+        if (event.type === "surface-changed") reconcile();
       });
     },
     stop() {
-      unsubscribe?.();
-      unsubscribe = void 0;
+      const state = session;
+      session = void 0;
+      if (!state) return;
+      state.active = false;
+      state.unsubscribe();
+      const { modelContext } = state;
+      if (state.incremental) {
+        for (const name of state.exposed.keys()) {
+          try {
+            modelContext.unregisterTool(name);
+          } catch {
+          }
+        }
+      } else if (typeof modelContext.clearContext === "function") {
+        modelContext.clearContext();
+      } else {
+        modelContext.provideContext({ tools: [] });
+      }
+      state.exposed.clear();
     }
   };
 }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/core-facade.ts","../src/index.ts"],"sourcesContent":["export { encodeWireName, encodeWireNameForInstance } from \"@agent-surface/core\";\nexport type {\n  AgentCapabilityDescriptorUnion,\n  AgentConsumer,\n  AgentSurfaceRegistry,\n  JsonSchema,\n  JsonValue,\n  SnapshotContext,\n} from \"@agent-surface/core\";\n\nexport function randomInvocationId(): string {\n  return `inv_${Math.random().toString(36).slice(2, 14)}`;\n}\n","import {\n  encodeWireName,\n  randomInvocationId,\n  type AgentCapabilityDescriptorUnion,\n  type AgentConsumer,\n  type AgentSurfaceRegistry,\n  type JsonSchema,\n  type JsonValue,\n  type SnapshotContext,\n} from \"./core-facade.js\";\n\n/* ───────────────────────── adapter contract (docs/09) ───────────────────────── */\n\nexport interface AdapterHost {\n  registry: AgentSurfaceRegistry;\n  consumer: AgentConsumer; // identity this adapter acts as\n  /** Adapter-scoped snapshot defaults (scope, budget). */\n  snapshotContext?: Omit<SnapshotContext, \"consumer\">;\n}\n\nexport interface AgentSurfaceAdapter {\n  readonly name: string;\n  start(host: AdapterHost): void | Promise<void>;\n  stop(): void | Promise<void>;\n}\n\n/* ───────────── assumed navigator.modelContext shape (Experimental) ─────────────\n * The WebMCP surface area is unstable (OQ-2); this module encodes the current\n * assumption and absorbs drift so nothing WebMCP-shaped leaks into core.\n */\n\nexport interface WebMcpToolInit {\n  name: string;\n  description: string;\n  inputSchema: JsonSchema;\n  execute(input: JsonValue): Promise<WebMcpToolResult>;\n}\n\nexport interface WebMcpToolResult {\n  content: Array<{ type: \"text\"; text: string }>;\n  isError?: boolean;\n}\n\nexport interface WebMcpModelContext {\n  provideContext(context: { tools: WebMcpToolInit[] }): void;\n}\n\nexport interface CreateWebMcpAdapterOptions {\n  snapshotContext?: Omit<SnapshotContext, \"consumer\">;\n  /**\n   * Curate presentation before exposing. Execution always remains registry-routed.\n   * Return null to skip; undefined to keep defaults.\n   */\n  exposeCapability?: (\n    descriptor: AgentCapabilityDescriptorUnion,\n  ) => { description?: string } | null | undefined;\n  /** Test seam: defaults to (navigator as any).modelContext. */\n  modelContext?: WebMcpModelContext;\n}\n\n/**\n * Maps the registry onto `navigator.modelContext`, treating WebMCP strictly\n * as transport/discovery: one wire-named tool per AVAILABLE capability,\n * re-provided on every surface-changed; unavailable capabilities are not\n * registered (WebMCP has no disabled state today — accepted limitation);\n * confirmations stay two-phase; absent modelContext ⇒ start() does nothing.\n */\nexport function createWebMcpAdapter(options?: CreateWebMcpAdapterOptions): AgentSurfaceAdapter {\n  let unsubscribe: (() => void) | undefined;\n\n  return {\n    name: \"webmcp\",\n\n    start(host: AdapterHost): void {\n      const modelContext =\n        options?.modelContext ??\n        (globalThis as { navigator?: { modelContext?: WebMcpModelContext } }).navigator\n          ?.modelContext;\n      if (!modelContext) return; // feature-detect, never polyfill\n\n      const provide = (): void => {\n        const snapshot = host.registry.snapshot({\n          consumer: host.consumer,\n          ...(options?.snapshotContext ?? host.snapshotContext ?? {}),\n          includeUnavailable: false,\n        });\n\n        const tools: WebMcpToolInit[] = [];\n\n        const toTool = (\n          descriptor: AgentCapabilityDescriptorUnion,\n          capabilityId: string,\n          registrationId: string,\n          inputSchema: JsonSchema,\n          description: string,\n        ): WebMcpToolInit => ({\n          name: encodeWireName(capabilityId),\n          description,\n          inputSchema,\n          execute: async (input: JsonValue): Promise<WebMcpToolResult> => {\n            const result = await host.registry.invoke(\n              {\n                invocationId: randomInvocationId(),\n                capabilityId,\n                registrationId,\n                surfaceVersion: snapshot.surfaceVersion,\n                ...(input !== undefined && Object.keys(input as object).length > 0\n                  ? { input }\n                  : {}),\n              },\n              { consumer: host.consumer },\n            );\n            // Capability errors ride in tool CONTENT, never protocol errors\n            // (docs/07 adapter mapping): code/retry/details preserved.\n            if (result.status === \"ok\") {\n              return {\n                content: [{ type: \"text\", text: JSON.stringify(result.output ?? null) }],\n              };\n            }\n            return {\n              content: [{ type: \"text\", text: JSON.stringify(result.error) }],\n              isError: true,\n            };\n          },\n        });\n\n        for (const component of snapshot.components) {\n          for (const obs of component.observations) {\n            if (!obs.available) continue;\n            const curated = options?.exposeCapability?.(obs);\n            if (options?.exposeCapability && curated === null) continue;\n            tools.push(\n              toTool(\n                obs,\n                obs.capabilityId,\n                component.registrationId,\n                { type: \"object\", properties: {}, additionalProperties: false },\n                curated?.description ?? `[view · read] ${obs.description}`,\n              ),\n            );\n          }\n          for (const act of component.actions) {\n            if (!act.available) continue;\n            const curated = options?.exposeCapability?.(act);\n            if (options?.exposeCapability && curated === null) continue;\n            tools.push(\n              toTool(\n                act,\n                act.capabilityId,\n                component.registrationId,\n                act.inputSchema,\n                curated?.description ?? `[view · ${act.effect}] ${act.description}`,\n              ),\n            );\n          }\n        }\n        for (const proc of snapshot.procedures) {\n          if (!proc.available) continue;\n          const curated = options?.exposeCapability?.(proc);\n          if (options?.exposeCapability && curated === null) continue;\n          tools.push(\n            toTool(\n              proc,\n              proc.procedureId,\n              proc.registrationId,\n              proc.inputSchema,\n              curated?.description ??\n                `[domain · ${proc.effect}${proc.confirmation === \"required\" ? \" · requires confirmation\" : \"\"}] ${proc.description}`,\n            ),\n          );\n        }\n\n        modelContext.provideContext({ tools });\n      };\n\n      provide();\n      unsubscribe = host.registry.subscribe((event) => {\n        if (event.type === \"surface-changed\") provide();\n      });\n    },\n\n    stop(): void {\n      unsubscribe?.();\n      unsubscribe = undefined;\n    },\n  };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/core-facade.ts","../src/index.ts"],"sourcesContent":["export { encodeWireName, encodeWireNameForInstance } from \"@agent-surface/core\";\nexport type {\n  AgentCapabilityDescriptorUnion,\n  AgentConsumer,\n  AgentSurfaceRegistry,\n  JsonSchema,\n  JsonValue,\n  PendingConfirmation,\n  SnapshotContext,\n} from \"@agent-surface/core\";\n\nexport function randomInvocationId(): string {\n  return `inv_${Math.random().toString(36).slice(2, 14)}`;\n}\n","import {\n  encodeWireName,\n  randomInvocationId,\n  type AgentCapabilityDescriptorUnion,\n  type AgentConsumer,\n  type AgentSurfaceRegistry,\n  type JsonSchema,\n  type JsonValue,\n  type PendingConfirmation,\n  type SnapshotContext,\n} from \"./core-facade.js\";\n\n/* ───────────────────────── adapter contract (docs/09) ───────────────────────── */\n\nexport interface AdapterHost {\n  registry: AgentSurfaceRegistry;\n  consumer: AgentConsumer; // identity this adapter acts as\n  /** Adapter-scoped snapshot defaults (scope, budget). */\n  snapshotContext?: Omit<SnapshotContext, \"consumer\">;\n}\n\nexport interface AgentSurfaceAdapter {\n  readonly name: string;\n  start(host: AdapterHost): void | Promise<void>;\n  stop(): void | Promise<void>;\n}\n\n/* ───────────── assumed navigator.modelContext shape (Experimental) ─────────────\n * The WebMCP surface area is unstable (OQ-2); this module encodes the current\n * assumption and absorbs drift so nothing WebMCP-shaped leaks into core.\n * Targeted revision: see \"Targeted WebMCP revision\" in docs/09.\n */\n\nexport interface WebMcpToolAnnotations {\n  /** The tool does not change state; a browser agent may skip its approval prompt. */\n  readOnlyHint?: boolean;\n}\n\n/** The per-call client WebMCP passes to `execute`. */\nexport interface WebMcpClient {\n  /** Pauses the tool call to run in-page UI; resolves with the callback's value. */\n  requestUserInteraction?<T>(callback: () => Promise<T>): Promise<T>;\n}\n\nexport interface WebMcpToolInit {\n  name: string;\n  description: string;\n  inputSchema: JsonSchema;\n  annotations?: WebMcpToolAnnotations;\n  execute(input: JsonValue, client?: WebMcpClient): Promise<WebMcpToolResult>;\n}\n\nexport interface WebMcpToolResult {\n  content: Array<{ type: \"text\"; text: string }>;\n  isError?: boolean;\n}\n\nexport interface WebMcpModelContext {\n  /** Replaces the whole tool set. Fallback when the incremental API is absent. */\n  provideContext(context: { tools: WebMcpToolInit[] }): void;\n  /** Removes every tool provided through provideContext. */\n  clearContext?(): void;\n  registerTool?(tool: WebMcpToolInit): unknown;\n  unregisterTool?(name: string): void;\n}\n\nexport interface CreateWebMcpAdapterOptions {\n  snapshotContext?: Omit<SnapshotContext, \"consumer\">;\n  /**\n   * Curate presentation before exposing. Execution always remains registry-routed.\n   * Return null to skip; undefined to keep defaults.\n   */\n  exposeCapability?: (\n    descriptor: AgentCapabilityDescriptorUnion,\n  ) => { description?: string } | null | undefined;\n  /**\n   * Opt-in in-page confirmation. When a call returns CONFIRMATION_REQUIRED and\n   * the WebMCP client supports `requestUserInteraction`, this host UI runs\n   * inside it; the answer resolves the registry's pending confirmation and the\n   * call is retried once, so the agent sees one final result. The registry\n   * stays the confirmation authority. Absent (or no client support) ⇒\n   * unchanged two-phase behavior.\n   */\n  confirm?: (request: PendingConfirmation, client: WebMcpClient) => Promise<boolean> | boolean;\n  /** Test seam: defaults to (navigator as any).modelContext. */\n  modelContext?: WebMcpModelContext;\n}\n\ninterface ToolTarget {\n  capabilityId: string;\n  registrationId: string;\n  /** Updated in place when the tool survives a surface change unchanged. */\n  surfaceVersion: string;\n}\n\ninterface ExposedTool {\n  tool: WebMcpToolInit;\n  target: ToolTarget;\n  /** Everything the browser agent sees, plus the registration it routes to. */\n  signature: string;\n}\n\ninterface DesiredTool {\n  name: string;\n  capabilityId: string;\n  registrationId: string;\n  inputSchema: JsonSchema;\n  description: string;\n  readOnly: boolean;\n}\n\nconst READ_ONLY_EFFECTS: ReadonlySet<string> = new Set([\"read\", \"server-query\"]);\n\n/**\n * Maps the registry onto `navigator.modelContext`, treating WebMCP strictly\n * as transport/discovery: one wire-named tool per AVAILABLE capability,\n * reconciled on every surface-changed (incremental registerTool/unregisterTool\n * when the browser supports it, full provideContext otherwise); unavailable\n * capabilities are not registered (WebMCP has no disabled state today —\n * accepted limitation); confirmations stay two-phase unless `confirm` is set;\n * absent modelContext ⇒ start() does nothing; stop() withdraws every tool.\n */\nexport function createWebMcpAdapter(options?: CreateWebMcpAdapterOptions): AgentSurfaceAdapter {\n  let session:\n    | {\n        modelContext: WebMcpModelContext;\n        incremental: boolean;\n        exposed: Map<string, ExposedTool>;\n        unsubscribe: () => void;\n        active: boolean;\n      }\n    | undefined;\n\n  return {\n    name: \"webmcp\",\n\n    start(host: AdapterHost): void {\n      if (session) return;\n      const modelContext =\n        options?.modelContext ??\n        (globalThis as { navigator?: { modelContext?: WebMcpModelContext } }).navigator\n          ?.modelContext;\n      if (!modelContext) return; // feature-detect, never polyfill\n\n      const incremental =\n        typeof modelContext.registerTool === \"function\" &&\n        typeof modelContext.unregisterTool === \"function\";\n      const state = {\n        modelContext,\n        incremental,\n        exposed: new Map<string, ExposedTool>(),\n        unsubscribe: () => {},\n        active: true,\n      };\n\n      const invoke = (target: ToolTarget, invocationId: string, input: JsonValue, confirmationId?: string) =>\n        host.registry.invoke(\n          {\n            invocationId,\n            capabilityId: target.capabilityId,\n            registrationId: target.registrationId,\n            surfaceVersion: target.surfaceVersion,\n            // Forwarded as given (like the core toolset): dropping `{}` made\n            // zero-argument actions fail INVALID_INPUT. Observations ignore input.\n            ...(input !== undefined ? { input } : {}),\n            ...(confirmationId !== undefined ? { confirmationId } : {}),\n          },\n          { consumer: host.consumer },\n        );\n\n      const toTool = (desired: DesiredTool, target: ToolTarget): WebMcpToolInit => ({\n        name: desired.name,\n        description: desired.description,\n        inputSchema: desired.inputSchema,\n        ...(desired.readOnly ? { annotations: { readOnlyHint: true } } : {}),\n        execute: async (input: JsonValue, client?: WebMcpClient): Promise<WebMcpToolResult> => {\n          const invocationId = randomInvocationId();\n          let result = await invoke(target, invocationId, input);\n\n          const confirmationId =\n            result.status === \"error\" && result.error.code === \"CONFIRMATION_REQUIRED\"\n              ? result.error.details?.confirmationId\n              : undefined;\n          if (\n            options?.confirm &&\n            typeof confirmationId === \"string\" &&\n            typeof client?.requestUserInteraction === \"function\" &&\n            state.active\n          ) {\n            const pending = host.registry.confirmations\n              .pending()\n              .find((record) => record.confirmationId === confirmationId);\n            if (pending) {\n              const confirm = options.confirm;\n              let approved: boolean | undefined;\n              try {\n                approved =\n                  (await client.requestUserInteraction(async () => confirm(pending, client))) ===\n                  true;\n              } catch {\n                approved = undefined; // UI failed: leave it pending, fall back to two-phase\n              }\n              // A stop() mid-prompt returns the pending result as-is (docs/09 §9).\n              if (approved !== undefined && state.active) {\n                host.registry.confirmations.resolve(\n                  confirmationId,\n                  approved ? { approved: true } : { approved: false, reason: \"Declined in page\" },\n                );\n                // Same invocationId + confirmationId (docs/03 D14): the registry\n                // decides the outcome, the adapter only relayed the answer.\n                result = await invoke(target, invocationId, input, confirmationId);\n              }\n            }\n          }\n\n          // Capability errors ride in tool CONTENT, never protocol errors\n          // (docs/07 adapter mapping): code/retry/details preserved.\n          if (result.status === \"ok\") {\n            return {\n              content: [{ type: \"text\", text: JSON.stringify(result.output ?? null) }],\n            };\n          }\n          return {\n            content: [{ type: \"text\", text: JSON.stringify(result.error) }],\n            isError: true,\n          };\n        },\n      });\n\n      const desiredTools = (): { surfaceVersion: string; tools: DesiredTool[] } => {\n        const snapshot = host.registry.snapshot({\n          consumer: host.consumer,\n          ...(options?.snapshotContext ?? host.snapshotContext ?? {}),\n          includeUnavailable: false,\n        });\n        const tools: DesiredTool[] = [];\n        const add = (\n          descriptor: AgentCapabilityDescriptorUnion,\n          capabilityId: string,\n          registrationId: string,\n          inputSchema: JsonSchema,\n          defaultDescription: string,\n          readOnly: boolean,\n        ): void => {\n          if (!descriptor.available) return;\n          const curated = options?.exposeCapability?.(descriptor);\n          if (options?.exposeCapability && curated === null) return;\n          tools.push({\n            name: encodeWireName(capabilityId),\n            capabilityId,\n            registrationId,\n            inputSchema,\n            description: curated?.description ?? defaultDescription,\n            // Derived from the declared kind/effect only; curation cannot widen it.\n            readOnly,\n          });\n        };\n\n        for (const component of snapshot.components) {\n          for (const obs of component.observations) {\n            add(\n              obs,\n              obs.capabilityId,\n              component.registrationId,\n              { type: \"object\", properties: {}, additionalProperties: false },\n              `[view · read] ${obs.description}`,\n              true,\n            );\n          }\n          for (const act of component.actions) {\n            add(\n              act,\n              act.capabilityId,\n              component.registrationId,\n              act.inputSchema,\n              `[view · ${act.effect}] ${act.description}`,\n              READ_ONLY_EFFECTS.has(act.effect),\n            );\n          }\n        }\n        for (const proc of snapshot.procedures) {\n          add(\n            proc,\n            proc.procedureId,\n            proc.registrationId,\n            proc.inputSchema,\n            `[domain · ${proc.effect}${proc.confirmation === \"required\" ? \" · requires confirmation\" : \"\"}] ${proc.description}`,\n            READ_ONLY_EFFECTS.has(proc.effect),\n          );\n        }\n        return { surfaceVersion: snapshot.surfaceVersion, tools };\n      };\n\n      const reconcile = (): void => {\n        if (!state.active) return;\n        const { surfaceVersion, tools } = desiredTools();\n        const next = new Map<string, ExposedTool>();\n        const toRegister: WebMcpToolInit[] = [];\n\n        for (const desired of tools) {\n          const signature = JSON.stringify([\n            desired.description,\n            desired.inputSchema,\n            desired.registrationId,\n            desired.capabilityId,\n            desired.readOnly,\n          ]);\n          const current = state.exposed.get(desired.name);\n          if (current && current.signature === signature) {\n            // Unchanged tool: keep the registration, refresh the version it\n            // echoes so execute carries the latest projected surfaceVersion.\n            current.target.surfaceVersion = surfaceVersion;\n            next.set(desired.name, current);\n            continue;\n          }\n          const target: ToolTarget = {\n            capabilityId: desired.capabilityId,\n            registrationId: desired.registrationId,\n            surfaceVersion,\n          };\n          const tool = toTool(desired, target);\n          next.set(desired.name, { tool, target, signature });\n          toRegister.push(tool);\n        }\n\n        if (state.incremental) {\n          for (const [name, current] of state.exposed) {\n            const replacement = next.get(name);\n            if (replacement !== current) modelContext.unregisterTool!(name);\n          }\n          for (const tool of toRegister) modelContext.registerTool!(tool);\n        } else {\n          modelContext.provideContext({ tools: [...next.values()].map((entry) => entry.tool) });\n        }\n        state.exposed = next;\n      };\n\n      session = state;\n      reconcile();\n      state.unsubscribe = host.registry.subscribe((event) => {\n        if (event.type === \"surface-changed\") reconcile();\n      });\n    },\n\n    stop(): void {\n      const state = session;\n      session = undefined;\n      if (!state) return; // idempotent\n      state.active = false;\n      state.unsubscribe();\n      const { modelContext } = state;\n      if (state.incremental) {\n        // Withdraw only our tools; other page code may own the rest.\n        for (const name of state.exposed.keys()) {\n          try {\n            modelContext.unregisterTool!(name);\n          } catch {\n            // Already gone on the browser side; nothing left to release.\n          }\n        }\n      } else if (typeof modelContext.clearContext === \"function\") {\n        modelContext.clearContext();\n      } else {\n        modelContext.provideContext({ tools: [] });\n      }\n      state.exposed.clear();\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-surface/webmcp",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "[Experimental] WebMCP (navigator.modelContext) transport adapter for agent-surface",
   "license": "MIT",
   "type": "module",
@@ -18,11 +18,11 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@agent-surface/core": "^0.24.0"
+    "@agent-surface/core": "^0.25.0"
   },
   "devDependencies": {
     "zod": "^4.1.5",
-    "@agent-surface/testing": "0.24.0"
+    "@agent-surface/testing": "0.25.0"
   },
   "author": "Paolo Barbato",
   "engines": {