rea-agents 3.1.0 → 3.2.0

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: {
@@ -37,7 +35,4 @@ export const authorizeRuntimeLocation = async (value, roots, origins) => {
     };
 };
 /** Authorize a target whose Node Inspector URL omits its main entry path. */
-export const authorizeRuntimeTargetLocation = async (value, targetType, roots, origins) => 
-// A bare file:// URL contains no source identity. Do not attach to the
-// first configured root merely because the target happens to be Node.
-authorizeRuntimeLocation(value, roots, origins);
+export const authorizeRuntimeTargetLocation = async (value) => authorizeRuntimeLocation(value);

package/dist/browser/PlaywrightBrowserScenarioProvider.js

@@ -1,8 +1,7 @@
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
-import { browserScenarioCaptureSchema, browserScenarioCompletenessSchema, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
+import { browserScenarioCaptureSchema, classifyBrowserScenarioCompleteness, browserScenarioStepSchema, browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
 import { AnalysisError, BrowserObservationError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
-import { BrowserScenarioCaptureBudget } from "./PlaywrightScenarioArtifacts.js";
 const OPERATION = "capture_browser_scenario";
 let defaultFactory;
 const lazyPlaywrightFactory = {
@@ -16,6 +15,14 @@ export const PLAYWRIGHT_BROWSER_SCENARIO_PROVIDER_IDENTITY = Object.freeze({
     name: "REA Playwright browser scenario capture provider",
     version: "1",
 });
+const SNAPSHOT_KINDS = [
+    "screenshot",
+    "dom",
+    "accessibility",
+    "url",
+    "history",
+    "storage",
+];
 const requestedForStep = (scenario, stepIndex) => new Set([
     ...scenario.capture.after_each_step,
     ...(stepIndex === scenario.actions.length ? scenario.capture.at_end : []),
@@ -34,25 +41,11 @@ const unavailableArtifacts = (requested, reason) => {
     });
 };
 const stepCompleteness = (artifacts, status) => {
-    const missing = Object.entries(artifacts)
-        .filter(([, state]) => state.state === "missing")
-        .map(([section]) => section);
-    const truncated = Object.entries(artifacts)
-        .filter(([, state]) => state.state === "truncated")
-        .map(([section]) => section);
+    const missing = SNAPSHOT_KINDS.filter((section) => artifacts[section].state === "missing");
+    const truncated = SNAPSHOT_KINDS.filter((section) => artifacts[section].state === "truncated");
     if (status !== "completed")
         missing.push("action");
-    const condition = truncated.length > 0
-        ? "truncated"
-        : missing.length > 0
-            ? "incomplete"
-            : "complete";
-    return browserScenarioCompletenessSchema.parse({
-        status: condition,
-        equality_eligible: condition === "complete",
-        missing_sections: [...new Set(missing)].sort(),
-        truncated_sections: [...new Set(truncated)].sort(),
-    });
+    return classifyBrowserScenarioCompleteness(missing, truncated);
 };
 const createStep = (input) => browserScenarioStepSchema.parse({
     step_index: input.stepIndex,
@@ -69,8 +62,8 @@ const createStep = (input) => browserScenarioStepSchema.parse({
     completeness: stepCompleteness(input.artifacts, input.status),
 });
 const initialStep = async (input) => {
-    const { session, scenario, budget, elapsedMs, maximumTimeoutMs, signal } = input;
-    const artifacts = await session.capture(requestedForStep(scenario, 0), budget, maximumTimeoutMs, signal);
+    const { session, scenario, elapsedMs, signal } = input;
+    const artifacts = await session.capture(requestedForStep(scenario, 0), signal);
     return createStep({
         stepIndex: 0,
         stepId: "scenario_start",
@@ -86,7 +79,7 @@ const initialStep = async (input) => {
     });
 };
 const executeStep = async (input) => {
-    const { session, scenario, budget, action, stepIndex, startedAt, priorFailure, signal, } = input;
+    const { session, scenario, action, stepIndex, priorFailure, signal } = input;
     const beforeUrl = session.currentUrl();
     const eventStart = session.nextEventSequence();
     const requested = requestedForStep(scenario, stepIndex);
@@ -107,40 +100,35 @@ const executeStep = async (input) => {
     const actionStartedAt = Date.now();
     session.setStep(stepIndex);
     const requestCancelled = () => signal?.aborted === true;
-    let status = "completed";
-    let error = null;
+    let outcome = {
+        status: "completed",
+        error: null,
+    };
     if (requestCancelled()) {
-        status = "cancelled";
-        error = "scenario request cancelled";
+        outcome = { status: "cancelled", error: "scenario request cancelled" };
     }
     else {
         try {
-            const elapsed = Date.now() - startedAt;
-            const remaining = scenario.limits.max_duration_ms - elapsed;
-            if (remaining <= 0)
-                throw new Error("Scenario duration limit reached");
-            await session.perform(action, remaining, signal);
+            await session.perform(action, signal);
         }
         catch (cause) {
-            status = requestCancelled() ? "cancelled" : "failed";
-            error = session.redactError(cause);
+            outcome = {
+                status: requestCancelled() ? "cancelled" : "failed",
+                error: session.redactError(cause),
+            };
         }
     }
-    const remaining = scenario.limits.max_duration_ms - (Date.now() - startedAt);
-    const artifacts = status === "cancelled" || remaining <= 0
-        ? unavailableArtifacts(requested, status === "cancelled"
-            ? "scenario request cancelled"
-            : "scenario duration limit reached")
-        : await session.capture(requested, budget, remaining, signal);
+    const artifacts = outcome.status === "cancelled"
+        ? unavailableArtifacts(requested, "scenario request cancelled")
+        : await session.capture(requested, signal);
     return createStep({
         stepIndex,
         stepId: action.step_id,
         action: action.action,
-        status,
+        ...outcome,
         elapsedMs: Date.now() - actionStartedAt,
         beforeUrl,
         afterUrl: session.currentUrl(),
-        error,
         eventStart,
         eventEnd: session.lastEventSequence(),
         artifacts,
@@ -149,40 +137,22 @@ const executeStep = async (input) => {
 const globalCompleteness = (scenario, session, steps) => {
     const missing = steps.flatMap(({ completeness }) => completeness.missing_sections);
     const truncated = steps.flatMap(({ completeness }) => completeness.truncated_sections);
-    truncated.push(...session.eventTruncationSections());
     if (session.mode === "connect")
         missing.push("events");
-    const status = truncated.length > 0
-        ? "truncated"
-        : missing.length > 0
-            ? "incomplete"
-            : "complete";
-    return browserScenarioCompletenessSchema.parse({
-        status,
-        equality_eligible: status === "complete",
-        missing_sections: [...new Set(missing)].sort(),
-        truncated_sections: [...new Set(truncated)].sort(),
-    });
+    return classifyBrowserScenarioCompleteness(missing, truncated);
 };
 const runScenario = async (factory, scenario, options) => {
     if (options.signal?.aborted === true)
         throw new BrowserObservationError(OPERATION, "cancelled");
     const startedAt = Date.now();
-    const budget = new BrowserScenarioCaptureBudget(scenario.limits.max_screenshots, scenario.limits.max_total_metadata_bytes);
-    const session = await factory.open(scenario, {
-        ...(options.signal === undefined ? {} : { signal: options.signal }),
-        budget,
-        deadlineAt: startedAt + scenario.limits.max_duration_ms,
-    });
+    const session = await factory.open(scenario, options.signal === undefined ? {} : { signal: options.signal });
     const steps = [];
     let cleanup;
     try {
         steps.push(await initialStep({
             session,
             scenario,
-            budget,
             elapsedMs: Date.now() - startedAt,
-            maximumTimeoutMs: scenario.limits.max_duration_ms - (Date.now() - startedAt),
             signal: options.signal,
         }));
         let failed = false;
@@ -190,10 +160,8 @@ const runScenario = async (factory, scenario, options) => {
             const step = await executeStep({
                 session,
                 scenario,
-                budget,
                 action,
                 stepIndex: offset + 1,
-                startedAt,
                 priorFailure: failed,
                 signal: options.signal,
             });
@@ -207,7 +175,6 @@ const runScenario = async (factory, scenario, options) => {
     const events = session.events();
     const completeness = globalCompleteness(scenario, session, steps);
     return browserScenarioCaptureSchema.parse({
-        schema_version: 1,
         browser: {
             mode: session.mode,
             process_ownership: session.processOwnership,