hilos-agent 0.9.4 → 0.10.0

package/src/webmcp-init.js

@@ -0,0 +1,281 @@
+// Installed before the first page script by `hilos-agent webmcp`.
+//
+// A native browser implementation wins when it exists. The fallback implements
+// the current imperative WebMCP surface closely enough for sites to register,
+// list, execute, abort, and retire page-scoped tools. The privileged hilos
+// wrapper deliberately exposes no DOM, cookies, storage, or arbitrary eval —
+// only bounded tool metadata and execution results.
+(() => {
+  "use strict";
+
+  const TOOL_NAME = /^[A-Za-z0-9_.-]{1,128}$/;
+  const MAX_TOOLS = 64;
+  const MAX_SCHEMA_CHARS = 32 * 1024;
+  const MAX_RESULT_CHARS = 64 * 1024;
+
+  const copyJson = (value) => {
+    if (value === undefined) return undefined;
+    return JSON.parse(JSON.stringify(value));
+  };
+
+  const domError = (message, name) => {
+    try {
+      return new DOMException(message, name);
+    } catch {
+      const error = new Error(message);
+      error.name = name;
+      return error;
+    }
+  };
+
+  function installFallbackModelContext() {
+    if (
+      document.modelContext &&
+      typeof document.modelContext.registerTool === "function" &&
+      typeof document.modelContext.getTools === "function" &&
+      typeof document.modelContext.executeTool === "function"
+    ) {
+      return document.modelContext;
+    }
+
+    const tools = new Map();
+    const events = new EventTarget();
+    let ontoolchange = null;
+
+    const notify = () => {
+      const event = new Event("toolchange");
+      events.dispatchEvent(event);
+      if (typeof ontoolchange === "function") {
+        try {
+          ontoolchange.call(context, event);
+        } catch {
+          // A page listener cannot break the browser mediator.
+        }
+      }
+    };
+
+    const context = {
+      registerTool(tool, options = {}) {
+        try {
+          if (!tool || typeof tool !== "object") {
+            throw new TypeError("WebMCP tool must be an object");
+          }
+          const name = String(tool.name || "");
+          const description = String(tool.description || "");
+          if (!TOOL_NAME.test(name)) {
+            throw new TypeError("WebMCP tool name is invalid");
+          }
+          if (!description) {
+            throw new TypeError("WebMCP tool description is required");
+          }
+          if (typeof tool.execute !== "function") {
+            throw new TypeError("WebMCP tool execute callback is required");
+          }
+          if (tools.has(name)) {
+            throw domError(`A WebMCP tool named ${name} is already registered`, "InvalidStateError");
+          }
+          if (options.signal?.aborted) {
+            throw options.signal.reason || domError("Registration aborted", "AbortError");
+          }
+
+          const inputSchema = copyJson(tool.inputSchema);
+          const schemaText = JSON.stringify(inputSchema ?? {});
+          if (schemaText.length > MAX_SCHEMA_CHARS) {
+            throw new TypeError("WebMCP input schema is too large");
+          }
+          const entry = {
+            name,
+            title: typeof tool.title === "string" ? tool.title : "",
+            description,
+            inputSchema,
+            annotations: tool.annotations
+              ? {
+                  readOnlyHint: tool.annotations.readOnlyHint === true,
+                  untrustedContentHint: tool.annotations.untrustedContentHint === true,
+                }
+              : undefined,
+            execute: tool.execute,
+            origin: location.origin,
+          };
+          tools.set(name, entry);
+          notify();
+
+          if (options.signal) {
+            options.signal.addEventListener(
+              "abort",
+              () => {
+                if (tools.get(name) !== entry) return;
+                tools.delete(name);
+                notify();
+              },
+              { once: true },
+            );
+          }
+          return Promise.resolve(undefined);
+        } catch (error) {
+          return Promise.reject(error);
+        }
+      },
+
+      async getTools() {
+        return [...tools.values()]
+          .sort((a, b) => a.name.localeCompare(b.name))
+          .map((tool) => ({
+            name: tool.name,
+            title: tool.title,
+            description: tool.description,
+            inputSchema: copyJson(tool.inputSchema),
+            window,
+            origin: tool.origin,
+            annotations: copyJson(tool.annotations),
+          }));
+      },
+
+      async executeTool(registeredTool, inputObject = {}, options = {}) {
+        if (!inputObject || typeof inputObject !== "object" || Array.isArray(inputObject)) {
+          throw new TypeError("WebMCP tool input must be an object");
+        }
+        if (options.signal?.aborted) {
+          throw options.signal.reason || domError("Execution aborted", "AbortError");
+        }
+        const name = String(registeredTool?.name || "");
+        const tool = tools.get(name);
+        if (!tool) throw domError(`WebMCP tool ${name} is not registered`, "NotFoundError");
+
+        const controller = new AbortController();
+        const onAbort = () => controller.abort(options.signal?.reason);
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        try {
+          const value = await tool.execute(copyJson(inputObject), { signal: controller.signal });
+          return JSON.stringify(value);
+        } finally {
+          options.signal?.removeEventListener("abort", onAbort);
+        }
+      },
+
+      addEventListener(...args) {
+        return events.addEventListener(...args);
+      },
+      removeEventListener(...args) {
+        return events.removeEventListener(...args);
+      },
+      dispatchEvent(...args) {
+        return events.dispatchEvent(...args);
+      },
+      get ontoolchange() {
+        return ontoolchange;
+      },
+      set ontoolchange(value) {
+        ontoolchange = typeof value === "function" ? value : null;
+      },
+    };
+
+    Object.defineProperty(document, "modelContext", {
+      configurable: false,
+      enumerable: true,
+      writable: false,
+      value: context,
+    });
+    return context;
+  }
+
+  const modelContext = installFallbackModelContext();
+
+  const source = () => ({
+    origin: location.origin,
+    pagePath: location.pathname || "/",
+  });
+
+  async function registeredTools() {
+    const tools = await modelContext.getTools();
+    return (Array.isArray(tools) ? tools : [])
+      .filter((tool) => tool && tool.origin === location.origin)
+      .slice(0, MAX_TOOLS);
+  }
+
+  const bridge = Object.freeze({
+    version: 1,
+    mode:
+      document.modelContext === modelContext &&
+      Object.prototype.hasOwnProperty.call(document, "modelContext")
+        ? "polyfill"
+        : "native",
+
+    async list() {
+      const tools = await registeredTools();
+      return {
+        ...source(),
+        tools: tools.map((tool) => {
+          let inputSchema = tool.inputSchema;
+          let schemaOmitted = false;
+          try {
+            // Chromium's first WebMCP implementation exposes RegisteredTool's
+            // schema as the draft's serialized JSON string; the current report
+            // exposes an object. Normalize both without passing site prose on.
+            if (typeof inputSchema === "string") inputSchema = JSON.parse(inputSchema);
+            if (JSON.stringify(inputSchema ?? {}).length > MAX_SCHEMA_CHARS) {
+              inputSchema = undefined;
+              schemaOmitted = true;
+            }
+          } catch {
+            inputSchema = undefined;
+            schemaOmitted = true;
+          }
+          return {
+            name: String(tool.name || "").slice(0, 128),
+            inputSchema: copyJson(inputSchema),
+            schemaOmitted,
+            annotations: tool.annotations
+              ? {
+                  readOnlyHint: tool.annotations.readOnlyHint === true,
+                  untrustedContentHint: tool.annotations.untrustedContentHint === true,
+                }
+              : undefined,
+          };
+        }),
+      };
+    },
+
+    async call(name, inputObject, timeoutMs = 30_000) {
+      const tools = await registeredTools();
+      const tool = tools.find((candidate) => candidate.name === name);
+      if (!tool) throw domError(`WebMCP tool ${name} is not registered`, "NotFoundError");
+
+      const controller = new AbortController();
+      const timer = setTimeout(
+        () => controller.abort(domError("WebMCP tool timed out", "TimeoutError")),
+        Math.max(1_000, Math.min(Number(timeoutMs) || 30_000, 60_000)),
+      );
+      try {
+        let result;
+        try {
+          result = await modelContext.executeTool(tool, inputObject, {
+            signal: controller.signal,
+          });
+        } catch (error) {
+          // Chromium's early draft expected a serialized input string. Only
+          // retry the pre-execution parse failure; an arbitrary tool failure
+          // might follow a side effect and must never be executed twice.
+          if (!/failed to parse input arguments/i.test(String(error?.message || error))) throw error;
+          result = await modelContext.executeTool(tool, JSON.stringify(inputObject), {
+            signal: controller.signal,
+          });
+        }
+        const resultJson = typeof result === "string" ? result : JSON.stringify(result);
+        if (resultJson.length > MAX_RESULT_CHARS) {
+          throw new RangeError("WebMCP tool result exceeds the 64 KB bridge limit");
+        }
+        return { ...source(), tool: name, resultJson };
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+  });
+
+  Object.defineProperty(window, "__hilosWebMcpBridge", {
+    configurable: false,
+    enumerable: false,
+    writable: false,
+    value: bridge,
+  });
+})();