rea-agents 3.0.0 → 3.2.0

package/dist/browser/CdpPageCapture.js

@@ -2,10 +2,11 @@ import { BrowserObservationError, } from "../domain/errors.js";
 import { stableWebResources } from "../domain/webInventory.js";
 import { CdpConnection } from "./CdpConnection.js";
 import { CdpCaptureEvents } from "./CdpCaptureEvents.js";
+import { authorizedMainFrame } from "./CdpAuthorizedMainFrame.js";
 import { captureStorage } from "./CdpCaptureStorage.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 import { captureAccessibility, captureDom, captureFrames, captureResources, mainFrameUrl, } from "./CdpCaptureDocuments.js";
-import { allowedSanitizedUrl, delayWithCancellation, isHttpUrl, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, delayWithCancellation, } from "./CdpCaptureValues.js";
 import { captureScripts } from "./CdpPageCaptureScripts.js";
 import { captureWorkers } from "./CdpPageCaptureWorkers.js";
 /** Capture and normalize one attached page without evaluating page JavaScript. */
@@ -23,7 +24,7 @@ export const capturePage = async (context) => {
         allowedOrigins,
         limitations: [
             "Observation starts when REA attaches; prior network and console activity is unavailable.",
-            "Raw network headers, bodies, cookies, storage values, console objects, and WebSocket payloads are never retained; separately approved captures retain only bounded redacted text or value-free shapes.",
+            "Raw network headers, bodies, cookies, storage values, console objects, and WebSocket payloads are never retained; separately approved captures retain only redacted text or value-free shapes.",
             "Source maps are reported only as declarative URLs and are not fetched.",
             "URL-less scripts and console events without an allowed source URL are excluded because their origin cannot be proven.",
         ],
@@ -41,26 +42,24 @@ const captureAuthorizedPage = async (state) => {
     const { connection, sessionId, input, signal } = context;
     await authorizeObservationWindow(state);
     await captureJsonResponseBodies(state);
-    const frameResult = await authorizedFrameTree(context, allowedOrigins);
+    const frameResult = await authorizedMainFrame({
+        connection: context.connection,
+        sessionId: context.sessionId,
+        signal: context.signal,
+        allowedOrigins,
+        delayOperation: context.operation,
+    });
     const attachedUrl = mainFrameUrl(frameResult) ?? "";
-    const frameCapture = captureFrames(frameResult, allowedOrigins, input.limits.max_frames, state.events.completeness);
+    const frameCapture = captureFrames(frameResult, allowedOrigins, undefined, state.events.completeness);
     const frames = frameCapture.items;
-    if (frameCapture.total > frames.length)
-        state.events.completeness.truncate("frames");
     const captureFrame = frames[0];
     if (captureFrame === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     state.events.beginFinalCapture(captureFrame.frame_id);
-    const resourceCapture = captureResources(await connection.send("Page.getResourceTree", {}, sessionId, signal), allowedOrigins, input.limits.max_resources, state.events.completeness);
-    if (resourceCapture.total > resourceCapture.items.length)
-        state.events.completeness.truncate("resources");
+    const resourceCapture = captureResources(await connection.send("Page.getResourceTree", {}, sessionId, signal), allowedOrigins, state.events.completeness);
     const resources = stableWebResources(resourceCapture.items.map(publicResource));
     const dom = await capturePageDom(state);
-    if (dom.total > dom.nodes.length)
-        state.events.completeness.truncate("dom");
     const accessibility = await accessibilityForFrames(state, frames);
-    if (accessibility.total > accessibility.nodes.length)
-        state.events.completeness.truncate("accessibility");
     const scripts = await captureScripts({
         context,
         events: state.events,
@@ -68,15 +67,17 @@ const captureAuthorizedPage = async (state) => {
         resources,
         frameIds: new Set(frames.map((frame) => frame.frame_id)),
     });
-    const workerCapture = await captureWorkers({ context, allowedOrigins, limitations, events: state.events }, new Set(frames.map((frame) => frame.frame_id)));
-    if (workerCapture.total > workerCapture.items.length)
-        state.events.completeness.truncate("workers");
+    const workers = await captureWorkers({ context, allowedOrigins, limitations, events: state.events }, new Set(frames.map((frame) => frame.frame_id)));
     const storageCapture = await captureStorage(context, frames[0]?.origin ?? new URL(attachedUrl).origin, limitations);
-    if (storageCapture.truncated)
-        state.events.completeness.truncate("storage_keys");
     if (!input.include_storage_keys)
         state.events.completeness.exclude("storage_keys", "not_approved", null);
-    const completedFrameResult = await authorizedFrameTree(context, allowedOrigins);
+    const completedFrameResult = await authorizedMainFrame({
+        connection: context.connection,
+        sessionId: context.sessionId,
+        signal: context.signal,
+        allowedOrigins,
+        delayOperation: context.operation,
+    });
     const completedUrl = mainFrameUrl(completedFrameResult) ?? "";
     if (state.events.originViolation)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
@@ -91,7 +92,7 @@ const captureAuthorizedPage = async (state) => {
             accessibility,
             scripts: scripts.inventory,
             resources,
-            workers: workerCapture.items,
+            workers,
             storage: storageCapture.value,
         }),
         sourceMapRequests: scripts.sourceMapRequests,
@@ -118,9 +119,14 @@ const authorizeObservationWindow = async (state) => {
     const { connection, sessionId, signal } = context;
     await report(context.progress, 1, "Enabling passive CDP domains");
     await connection.send("Page.enable", {}, sessionId, signal);
-    const initialFrameResult = await authorizedFrameTree(context, allowedOrigins);
-    const mainFrame = captureFrames(initialFrameResult, allowedOrigins, 1)
-        .items[0];
+    const initialFrameResult = await authorizedMainFrame({
+        connection: context.connection,
+        sessionId: context.sessionId,
+        signal: context.signal,
+        allowedOrigins,
+        delayOperation: context.operation,
+    });
+    const mainFrame = captureFrames(initialFrameResult, allowedOrigins).items[0];
     if (mainFrame === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
     events.beginAuthorizedFrame(mainFrame.frame_id);
@@ -140,7 +146,6 @@ const capturePageDom = async (state) => {
     return captureDom(result, allowedOrigins, context.input, state.events.completeness);
 };
 const normalizedInspection = (state, captured) => ({
-    schema_version: 2,
     browser: state.context.discovery.version,
     target: normalizedTarget(state.context.target, captured.attachedUrl, state.allowedOrigins),
     capture_window: {
@@ -183,32 +188,17 @@ const normalizedInspection = (state, captured) => ({
     storage: captured.storage,
     limitations: state.limitations,
 });
-const authorizedFrameTree = async (context, allowedOrigins) => {
-    for (let attempt = 0; attempt < 80; attempt += 1) {
-        const result = await context.connection.send("Page.getFrameTree", {}, context.sessionId, context.signal);
-        const currentUrl = mainFrameUrl(result);
-        if (allowedSanitizedUrl(currentUrl, allowedOrigins) !== undefined)
-            return result;
-        if (isHttpUrl(currentUrl))
-            throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-        await delayWithCancellation(25, context.operation, context.signal);
-    }
-    throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-};
 const enableObservationDomains = async (connection, sessionId, signal) => {
     await connection.send("Runtime.enable", {}, sessionId, signal);
-    await connection.send("Debugger.enable", { maxScriptsCacheSize: 4 * 1_024 * 1_024 }, sessionId, signal);
-    await connection.send("Network.enable", {
-        maxTotalBufferSize: 4 * 1_024 * 1_024,
-        maxResourceBufferSize: 1_024 * 1_024,
-    }, sessionId, signal);
+    await connection.send("Debugger.enable", {}, sessionId, signal);
+    await connection.send("Network.enable", {}, sessionId, signal);
 };
 const accessibilityForFrames = async (state, frames) => {
     const { context, limitations, events } = state;
     const results = [];
     let unavailable = false;
     for (const frame of frames) {
-        const result = await optionalCdpCommand(context, "Accessibility.getFullAXTree", { depth: 32, frameId: frame.frame_id }, limitations);
+        const result = await optionalCdpCommand(context, "Accessibility.getFullAXTree", { frameId: frame.frame_id }, limitations);
         if (result === undefined)
             unavailable = true;
         else
@@ -216,16 +206,12 @@ const accessibilityForFrames = async (state, frames) => {
     }
     if (unavailable)
         events.completeness.unavailable("accessibility");
-    const capture = captureAccessibility(results, context.input.limits.max_ax_nodes, {
+    const capture = captureAccessibility(results, {
         includeText: context.input.include_accessibility_text,
-        maximumFieldBytes: context.input.limits.max_ax_text_field_bytes,
-        maximumTotalBytes: context.input.limits.max_total_ax_text_bytes,
         ...(results.length === 0 && unavailable ? { unavailable: true } : {}),
     });
     if (!context.input.include_accessibility_text)
         events.completeness.exclude("accessibility", "not_approved", capture.textCapture.excluded_fields);
-    if (capture.textCapture.status === "truncated")
-        events.completeness.truncate("accessibility");
     if (capture.treeIncomplete)
         events.completeness.truncate("accessibility");
     return capture;
@@ -246,7 +232,7 @@ const normalizedTarget = (target, currentUrl, allowedOrigins) => {
     return {
         target_id: target.id,
         type: target.type,
-        title: target.title.slice(0, 16_384),
+        title: target.title,
         url: url?.url ?? "[unsupported-url]",
         origin: url?.origin ?? "",
         attached: target.attached,

package/dist/browser/CdpPageCaptureScripts.js

@@ -8,7 +8,6 @@ export const captureScripts = async (options) => {
         frameIds,
         rawResources,
         resources,
-        totalSourceBytes: 0,
     };
     const drafts = [];
     for (const script of events.scripts.values())
@@ -42,26 +41,9 @@ const buildScriptDraft = async (script, state) => {
     };
 };
 const captureScriptSource = async (script, state) => {
-    const { context, events } = state;
-    if (script.length > context.input.limits.max_script_source_bytes) {
-        events.completeness.truncate("script_sources");
-        return sourceExcluded("declared script length exceeds per-script limit");
-    }
-    if (state.totalSourceBytes + script.length >
-        context.input.limits.max_total_script_source_bytes) {
-        events.completeness.truncate("script_sources");
-        return sourceExcluded("total script source limit reached");
-    }
+    const { context } = state;
     const result = requiredRecord(await context.connection.send("Debugger.getScriptSource", { scriptId: script.scriptId }, context.sessionId, context.signal));
     const content = stringValue(result.scriptSource) ?? "";
-    const bytes = Buffer.byteLength(content);
-    if (bytes > context.input.limits.max_script_source_bytes ||
-        state.totalSourceBytes + bytes >
-            context.input.limits.max_total_script_source_bytes) {
-        events.completeness.truncate("script_sources");
-        return sourceExcluded("actual source exceeds configured byte limits");
-    }
-    state.totalSourceBytes += bytes;
     return sourceResult(content);
 };
 const keyAndBuildInventory = (drafts, scriptCount) => {

package/dist/browser/CdpPageCaptureWorkers.js

@@ -1,11 +1,10 @@
-import { allowedSanitizedUrl, boundedText, isHttpUrl, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, isHttpUrl, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
 export const captureWorkers = async (input, frameIds) => {
     const { context, allowedOrigins, limitations, events } = input;
     const completeness = events.completeness;
     const result = await optionalCdpCommand({ ...context, sessionId: undefined }, "Target.getTargets", {}, limitations);
     const items = [];
-    let total = 0;
     if (result === undefined)
         completeness.unavailable("workers");
     for (const target of recordsValue(recordValue(result)?.targetInfos)) {
@@ -29,18 +28,15 @@ export const captureWorkers = async (input, frameIds) => {
                     : "unsupported_url");
             continue;
         }
-        total += 1;
-        if (items.length >= context.input.limits.max_workers)
-            continue;
         items.push({
-            target_id: (stringValue(target.targetId) ?? "").slice(0, 256),
-            type: type.slice(0, 100),
+            target_id: stringValue(target.targetId) ?? "",
+            type,
             url: url.url,
             origin: url.origin,
             attached: target.attached === true,
-            opener_target_id: boundedText(target.openerId, 256) ?? null,
-            parent_frame_id: boundedText(target.parentFrameId, 256) ?? null,
+            opener_target_id: stringValue(target.openerId) ?? null,
+            parent_frame_id: stringValue(target.parentFrameId) ?? null,
         });
     }
-    return { total, items };
+    return items;
 };

package/dist/browser/CdpSafeMetadata.js

@@ -37,15 +37,15 @@ const normalizedHeaders = (value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return new Map();
     const headers = new Map();
-    for (const [name, raw] of Object.entries(value).slice(0, 500)) {
-        const normalized = name.toLowerCase().slice(0, 256);
+    for (const [name, raw] of Object.entries(value)) {
+        const normalized = name.toLowerCase();
         const header = typeof raw === "string"
             ? raw
             : typeof raw === "number" && Number.isFinite(raw)
                 ? String(raw)
                 : undefined;
         if (header !== undefined)
-            headers.set(normalized, header.slice(0, 65_536));
+            headers.set(normalized, header);
     }
     return headers;
 };
@@ -53,13 +53,13 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
     const directives = [];
     let nonceCount = 0;
     let hashCount = 0;
-    for (const rawDirective of (value ?? "").split(";").slice(0, 100)) {
+    for (const rawDirective of (value ?? "").split(";")) {
         const [rawName, ...tokens] = rawDirective.trim().split(/\s+/u);
         const name = (rawName ?? "").toLowerCase();
-        if (!/^[a-z][a-z0-9-]{0,99}$/u.test(name))
+        if (!/^[a-z][a-z0-9-]*$/u.test(name))
             continue;
         const sources = [];
-        for (const token of tokens.slice(0, 100)) {
+        for (const token of tokens) {
             const lower = token.toLowerCase();
             if (lower.startsWith("'nonce-")) {
                 nonceCount += 1;
@@ -80,9 +80,9 @@ const parseCsp = (value, baseUrl, allowedOrigins) => {
 const cspSource = (token, baseUrl, allowedOrigins) => {
     const lower = token.toLowerCase();
     if (/^'[a-z0-9-]+'$/u.test(lower))
-        return { kind: "keyword", value: lower.slice(0, 100) };
+        return { kind: "keyword", value: lower };
     if (/^[a-z][a-z0-9+.-]*:$/u.test(lower))
-        return { kind: "scheme", value: lower.slice(0, 100) };
+        return { kind: "scheme", value: lower };
     try {
         const parsed = new URL(token, baseUrl);
         return allowedOrigins.has(parsed.origin)
@@ -95,8 +95,8 @@ const cspSource = (token, baseUrl, allowedOrigins) => {
 };
 const parseLinks = (value, baseUrl, allowedOrigins) => {
     const links = [];
-    for (const entry of splitLinkHeader(value ?? "").slice(0, 100)) {
-        const match = /^\s*<([^>]{1,4096})>(.*)$/u.exec(entry);
+    for (const entry of splitLinkHeader(value ?? "")) {
+        const match = /^\s*<([^>]*)>(.*)$/u.exec(entry);
         if (match === null)
             continue;
         const parameters = linkParameters(match[2] ?? "");
@@ -107,8 +107,7 @@ const parseLinks = (value, baseUrl, allowedOrigins) => {
             rel: (parameters.get("rel") ?? "")
                 .toLowerCase()
                 .split(/\s+/u)
-                .filter(Boolean)
-                .slice(0, 32),
+                .filter(Boolean),
             as: boundedHeader(parameters.get("as")),
             type: boundedHeader(parameters.get("type")),
             crossorigin: boundedHeader(parameters.get("crossorigin")),
@@ -134,15 +133,15 @@ const splitLinkHeader = (value) => {
 };
 const linkParameters = (value) => {
     const parameters = new Map();
-    for (const raw of value.split(";").slice(1, 50)) {
+    for (const raw of value.split(";").slice(1)) {
         const separator = raw.indexOf("=");
         const name = (separator < 0 ? raw : raw.slice(0, separator))
             .trim()
             .toLowerCase();
-        if (!/^[a-z][a-z0-9-]{0,99}$/u.test(name))
+        if (!/^[a-z][a-z0-9-]*$/u.test(name))
             continue;
         const parameter = separator < 0 ? "" : raw.slice(separator + 1).trim();
-        parameters.set(name, unquote(parameter).slice(0, 1_024));
+        parameters.set(name, unquote(parameter));
     }
     return parameters;
 };
@@ -163,10 +162,8 @@ const permissionFeatures = (value) => [
     ...new Set((value ?? "")
         .split(",")
         .map((entry) => entry.split("=", 1)[0]?.trim().toLowerCase() ?? "")
-        .filter((feature) => /^[a-z][a-z0-9-]{0,99}$/u.test(feature))),
-]
-    .sort()
-    .slice(0, 200);
+        .filter((feature) => /^[a-z][a-z0-9-]*$/u.test(feature))),
+].sort();
 const wellKnownHint = (url) => {
     try {
         const path = new URL(url).pathname.toLowerCase();
@@ -180,20 +177,20 @@ const wellKnownHint = (url) => {
 };
 const agentHint = (mechanism, declaration, url) => ({
     mechanism,
-    declaration: declaration.slice(0, 256),
+    declaration,
     url,
     trust: "page-declared-untrusted",
 });
 const isAgentRel = (value) => ["mcp", "model-context", "ai-plugin", "service-desc"].includes(value);
 const policyToken = (value) => {
     const token = (value ?? "").trim().toLowerCase();
-    return /^[a-z][a-z0-9_.-]{0,99}$/u.test(token) ? token : null;
+    return /^[a-z][a-z0-9_.-]*$/u.test(token) ? token : null;
 };
 const nonnegativeInteger = (value) => {
     const number = numberValue(value === undefined ? undefined : Number(value));
     return number === undefined ? null : Math.max(0, Math.trunc(number));
 };
-const boundedHeader = (value) => value === undefined ? null : value.trim().toLowerCase().slice(0, 256);
+const boundedHeader = (value) => value === undefined ? null : value.trim().toLowerCase();
 const unquote = (value) => value.startsWith('"') && value.endsWith('"') ? value.slice(1, -1) : value;
 const agentHeaderNames = ["x-model-context", "x-webmcp", "mcp-server"];
 const wellKnownAgentPaths = new Set([

package/dist/browser/CdpScreenshot.js

@@ -38,8 +38,7 @@ export const captureCdpScreenshot = async (context) => {
     }
     const encoded = stringValue(result?.data);
     const bytes = encoded === undefined ? undefined : decodeCanonicalBase64(encoded);
-    if (bytes === undefined ||
-        bytes.byteLength > context.input.maximum_image_bytes)
+    if (bytes === undefined)
         throw new BrowserObservationError("inspect_web_page", "payload_limit");
     const dimensions = pngDimensions(bytes);
     if (navigation.leftScope)
@@ -57,7 +56,6 @@ export const captureCdpScreenshot = async (context) => {
         terminal: true,
     });
     return {
-        schema_version: 1,
         browser: context.discovery.version,
         target: {
             target_id: context.target.id,
@@ -94,8 +92,8 @@ const pngDimensions = (bytes) => {
         throw new BrowserObservationError("inspect_web_page", "protocol_error");
     const width = bytes.readUInt32BE(16);
     const height = bytes.readUInt32BE(20);
-    if (width === 0 || height === 0 || width * height > 32_000_000)
-        throw new BrowserObservationError("inspect_web_page", "payload_limit");
+    if (width === 0 || height === 0)
+        throw new BrowserObservationError("inspect_web_page", "protocol_error");
     return { width, height };
 };
 const PNG_SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);

package/dist/browser/CdpTargetSession.js

@@ -40,8 +40,7 @@ const attachedSessionId = (value, operation) => {
         value === null ||
         !("sessionId" in value) ||
         typeof value.sessionId !== "string" ||
-        value.sessionId.length === 0 ||
-        value.sessionId.length > 256)
+        value.sessionId.length === 0)
         throw new BrowserObservationError(operation, "protocol_error");
     return value.sessionId;
 };

package/dist/browser/CdpWebMcpDiscovery.js

@@ -5,7 +5,7 @@ import { BrowserObservationError } from "../domain/errors.js";
 import { allowedSanitizedUrl, delayWithCancellation, numberValue, recordValue, recordsValue, stringValue, } from "./CdpCaptureValues.js";
 import { captureFrames, mainFrameUrl } from "./CdpCaptureDocuments.js";
 import { optionalCdpCommand } from "./CdpOptionalCommand.js";
-import { boundedSensitiveText } from "./SensitiveTextCapture.js";
+import { redactSensitiveText } from "./SensitiveTextCapture.js";
 /** Discover WebMCP registrations without evaluating or invoking page code. */
 export const discoverWebMcp = async (context) => {
     const origins = new Set(context.input.allowed_origins);
@@ -19,7 +19,7 @@ export const discoverWebMcp = async (context) => {
     const initialUrl = mainFrameUrl(frameTree);
     if (allowedSanitizedUrl(initialUrl, origins) === undefined)
         throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
-    const frames = captureFrames(frameTree, origins, 1_000, completeness).items;
+    const frames = captureFrames(frameTree, origins, undefined, completeness).items;
     const frameUrls = new Map(frames.map((frame) => [
         frame.frame_id,
         {
@@ -57,7 +57,7 @@ export const discoverWebMcp = async (context) => {
         }
         else
             // CDP sends the enable response before the required toolsAdded replay.
-            await delayWithCancellation(Math.max(context.input.observation_ms, 25), "discover_webmcp_tools", context.signal);
+            await delayWithCancellation(context.input.observation_ms, "discover_webmcp_tools", context.signal);
         await assertStableAuthorizedFrame(context, initialUrl, origins);
         return buildWebMcpResult({
             context,
@@ -96,7 +96,7 @@ const ingestFrameScopeEvent = (event, state) => {
 };
 const handleFrameDetached = (params, state) => {
     const frameId = stringValue(params.frameId);
-    if (frameId === undefined || frameId.length > 256) {
+    if (frameId === undefined) {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
     }
@@ -105,7 +105,7 @@ const handleFrameDetached = (params, state) => {
 };
 const handleFrameUpdate = (frame, state) => {
     const frameId = stringValue(frame?.id) ?? stringValue(frame?.frameId);
-    if (frameId === undefined || frameId.length > 256) {
+    if (frameId === undefined) {
         state.completeness.exclude("webmcp_tools", "invalid_protocol_value");
         return true;
     }
@@ -173,10 +173,6 @@ const ingestWebMcpEvent = (options) => {
         const normalized = normalizeTool(declared, input, frames, completeness);
         if (normalized === undefined)
             continue;
-        if (!tools.has(normalized.tool_key) && tools.size >= input.max_tools) {
-            completeness.drop("webmcp_tools");
-            continue;
-        }
         tools.set(normalized.tool_key, normalized);
     }
 };
@@ -191,19 +187,19 @@ const normalizeTool = (value, input, frames, completeness) => {
         completeness.exclude("webmcp_tools", "out_of_target_scope");
         return undefined;
     }
-    const description = boundedSensitiveText(stringValue(value.description) ?? "", 4_096).text;
+    const description = redactSensitiveText(stringValue(value.description) ?? "");
     const annotations = recordValue(value.annotations);
     return {
         tool_key: toolKey(frame.url, name),
-        name: boundedSensitiveText(name, 512).text,
+        name: redactSensitiveText(name),
         description,
-        frame_id: frameId.slice(0, 256),
+        frame_id: frameId,
         frame_url: frame.url,
         owner_origin: frame.origin,
         declaration_kind: numberValue(value.backendNodeId) === undefined
             ? "imperative"
             : "declarative",
-        input_schema_shape: schemaShape(value.inputSchema, input, completeness),
+        input_schema_shape: schemaShape(value.inputSchema),
         annotations: {
             read_only: booleanOrNull(annotations?.readOnly),
             untrusted_content: booleanOrNull(annotations?.untrustedContent),
@@ -213,17 +209,13 @@ const normalizeTool = (value, input, frames, completeness) => {
         trust: "page-declared-untrusted",
     };
 };
-const schemaShape = (value, input, completeness) => {
+const schemaShape = (value) => {
     if (recordValue(value) === undefined)
         return null;
     const encoded = JSON.stringify(value);
-    const shape = inferJsonShape(encoded, {
-        maximumBytes: input.max_schema_bytes,
-        maximumNodes: input.max_schema_nodes,
-        maximumDepth: input.max_schema_depth,
-    });
-    if (shape === null || shape.truncated)
-        completeness.truncate("webmcp_tools");
+    const shape = inferJsonShape(encoded);
+    if (shape === null)
+        throw new BrowserObservationError("inspect_web_page", "protocol_error");
     return shape;
 };
 const registrationSource = (stack, allowedOrigins) => {
@@ -242,7 +234,6 @@ const buildWebMcpResult = (options) => {
     const targetUrl = mainFrameUrl(frameTree) ?? context.target.url;
     const sanitized = allowedSanitizedUrl(targetUrl, new Set(context.input.allowed_origins));
     return {
-        schema_version: 1,
         browser: context.discovery.version,
         target: {
             target_id: context.target.id,

package/dist/browser/ElectronFileScope.js

@@ -1,16 +1,9 @@
-import { realpath } from "node:fs/promises";
-import { isAbsolute, relative } from "node:path";
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
-/** Canonicalize operator roots before evaluating any Electron file target. */
-export const canonicalElectronRoots = async (roots) => {
-    const canonical = [];
-    for (const root of roots)
-        canonical.push(await realpath(root));
-    return [...new Set(canonical)].sort();
-};
-/** Resolve one file URL and reject host, encoding, and symlink root escapes. */
-export const authorizedElectronFile = async (value, roots) => {
-    if (value.length > 65_536 || /%(?:2f|5c)/iu.test(value))
+/** Resolve one local file URL while rejecting remote hosts and encoded separators. */
+export const authorizedElectronFile = async (value) => {
+    if (/%(?:2f|5c)/iu.test(value))
         return undefined;
     let url;
     try {
@@ -35,16 +28,12 @@ export const authorizedElectronFile = async (value, roots) => {
         return undefined;
     let canonical;
     try {
+        if (!(await stat(path)).isFile())
+            return undefined;
         canonical = await realpath(path);
     }
     catch {
         return undefined;
     }
-    return roots.some((root) => withinRoot(root, canonical))
-        ? canonical
-        : undefined;
-};
-const withinRoot = (root, path) => {
-    const remainder = relative(root, path);
-    return (remainder === "" || (!remainder.startsWith("..") && !isAbsolute(remainder)));
+    return canonical;
 };

package/dist/browser/JavaScriptRuntimeScope.js

@@ -1,18 +1,16 @@
 import { browserOriginSchema, sanitizeBrowserUrl, } from "../domain/browserObservation.js";
-import { authorizedElectronFile, canonicalElectronRoots, } from "./ElectronFileScope.js";
-/** Canonicalize exact filesystem scopes before Inspector attachment. */
-export const canonicalRuntimeRoots = canonicalElectronRoots;
-/** Authorize one protocol URL without retaining an out-of-scope value. */
-export const authorizeRuntimeLocation = async (value, roots, origins) => {
-    if (value.startsWith("node:") && value.length <= 4_096)
+import { authorizedElectronFile } from "./ElectronFileScope.js";
+/** Resolve a protocol location exposed by the explicitly selected Inspector endpoint. */
+export const authorizeRuntimeLocation = async (value) => {
+    if (value.startsWith("node:") && value.length > 0)
         return {
             allowed: true,
             location: { kind: "builtin", specifier: value },
         };
     if (value.startsWith("file:")) {
-        const filePath = await authorizedElectronFile(value, roots);
+        const filePath = await authorizedElectronFile(value);
         return filePath === undefined
-            ? { allowed: false, reason: "outside_file_roots" }
+            ? { allowed: false, reason: "unsupported_location" }
             : { allowed: true, location: { kind: "file", file_path: filePath } };
     }
     let url;
@@ -25,8 +23,8 @@ export const authorizeRuntimeLocation = async (value, roots, origins) => {
     if (!["http:", "https:"].includes(url.protocol))
         return { allowed: false, reason: "unsupported_location" };
     const parsedOrigin = browserOriginSchema.safeParse(url.origin);
-    if (!parsedOrigin.success || !origins.includes(parsedOrigin.data))
-        return { allowed: false, reason: "outside_origins" };
+    if (!parsedOrigin.success)
+        return { allowed: false, reason: "unsupported_location" };
     return {
         allowed: true,
         location: {
@@ -36,3 +34,5 @@ export const authorizeRuntimeLocation = async (value, roots, origins) => {
         },
     };
 };
+/** Authorize a target whose Node Inspector URL omits its main entry path. */
+export const authorizeRuntimeTargetLocation = async (value) => authorizeRuntimeLocation(value);