rea-agents 3.1.0 → 3.2.0

package/dist/artifacts/SafeOutputTree.js

@@ -1,28 +1,23 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
-import { lstat, mkdir, open, realpath, rm } from "node:fs/promises";
+import { lstat, mkdir, open, realpath, rm, } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { streamChunkToBuffer } from "./StreamBytes.js";
 import { ArtifactPathRegistry, normalizeArtifactPath, } from "./ArtifactPaths.js";
-import { ArtifactReaderFailure, } from "./ArtifactReader.js";
+import { ArtifactReaderFailure } from "./ArtifactReader.js";
 /** Symlink-resistant materialization in an exclusively owned, initially absent tree. */
 export class SafeOutputTree {
     #registry = new ArtifactPathRegistry();
-    #limits;
     #outputRoot;
-    #stagingRoot;
-    #totalBytes = 0;
     #published = false;
     #cleanup = {
         status: "not-required",
     };
-    constructor(outputRoot, stagingRoot, limits) {
+    constructor(outputRoot) {
         this.#outputRoot = outputRoot;
-        this.#stagingRoot = stagingRoot;
-        this.#limits = limits;
     }
     /** Exclusively create the absent destination as this operation's owned tree. */
-    static async create(outputRoot, limits) {
+    static async create(outputRoot) {
         if (!isAbsolute(outputRoot))
             throw new ArtifactReaderFailure("path", "Extraction output root must be absolute");
         const requested = resolve(outputRoot);
@@ -46,7 +41,7 @@ export class SafeOutputTree {
             finally {
                 await stagingHandle.close();
             }
-            return new SafeOutputTree(canonicalOutput, canonicalOutput, limits);
+            return new SafeOutputTree(canonicalOutput);
         }
         catch (cause) {
             await rm(canonicalOutput, { recursive: true, force: true });
@@ -59,10 +54,10 @@ export class SafeOutputTree {
     get cleanup() {
         return structuredClone(this.#cleanup);
     }
-    /** Stream one selected regular file with exact byte and digest verification. */
+    /** Stream one regular file with exact byte and digest verification. */
     async write(relativePath, source, expectedSha256, signal) {
         this.#assertWritable();
-        const path = normalizeArtifactPath(relativePath, this.#limits);
+        const path = normalizeArtifactPath(relativePath);
         this.#registry.add(path, "file");
         const destination = await this.#prepareParent(path);
         const handle = await open(destination, constants.O_CREAT |
@@ -78,10 +73,6 @@ export class SafeOutputTree {
                 abortIfNeeded(signal);
                 const chunk = streamChunkToBuffer(raw);
                 bytes += chunk.length;
-                if (bytes > this.#limits.maxEntryBytes)
-                    throw new ArtifactReaderFailure("limit", `Observed entry bytes exceed limit: ${path}`);
-                if (this.#totalBytes + bytes > this.#limits.maxTotalBytes)
-                    throw new ArtifactReaderFailure("limit", "Observed extraction bytes exceed cumulative limit");
                 hash.update(chunk);
                 await writeAll(handle, chunk);
             }
@@ -93,7 +84,6 @@ export class SafeOutputTree {
             const readback = await hashFile(destination, bytes, signal);
             if (readback.sha256 !== sha256 || readback.bytes !== bytes)
                 throw new ArtifactReaderFailure("integrity", `Durable readback verification failed: ${path}`);
-            this.#totalBytes += bytes;
             return { relativePath: path, sha256, bytesWritten: bytes };
         }
         catch (cause) {
@@ -105,9 +95,10 @@ export class SafeOutputTree {
     async commit() {
         this.#assertWritable();
         const parent = await open(dirname(this.#outputRoot), constants.O_RDONLY | constants.O_DIRECTORY);
-        const staging = await open(this.#stagingRoot, constants.O_RDONLY | constants.O_DIRECTORY);
+        let output;
         try {
-            await staging.sync();
+            output = await open(this.#outputRoot, constants.O_RDONLY | constants.O_DIRECTORY);
+            await output.sync();
             await parent.sync();
             this.#published = true;
         }
@@ -115,20 +106,20 @@ export class SafeOutputTree {
             throw new ArtifactReaderFailure("path", "Could not durably sync extraction output", { cause });
         }
         finally {
-            await Promise.allSettled([parent.close(), staging.close()]);
+            await Promise.allSettled([parent.close(), output?.close()]);
         }
     }
     /** Remove only this operation's unsealed tree and verify absence. */
     async rollback() {
         if (this.#published)
             return structuredClone(this.#cleanup);
-        await rm(this.#stagingRoot, { recursive: true, force: true });
-        const absent = await isAbsent(this.#stagingRoot);
+        await rm(this.#outputRoot, { recursive: true, force: true });
+        const absent = await isAbsent(this.#outputRoot);
         this.#cleanup = absent
             ? { status: "complete", residualPaths: [] }
             : {
                 status: "incomplete",
-                residualPaths: [basename(this.#stagingRoot)],
+                residualPaths: [basename(this.#outputRoot)],
             };
         if (!absent)
             throw new ArtifactReaderFailure("integrity", "Extraction output cleanup could not be verified");
@@ -139,7 +130,7 @@ export class SafeOutputTree {
         const fileName = parts.pop();
         if (fileName === undefined)
             throw new ArtifactReaderFailure("path", "Invalid extraction path");
-        let current = this.#stagingRoot;
+        let current = this.#outputRoot;
         for (const part of parts) {
             current = join(current, part);
             await mkdir(current, { mode: 0o700 }).catch((cause) => {

package/dist/browser/BrowserProcessStartup.js

@@ -69,7 +69,7 @@ const startupError = (options, startedAt, state) => new BrowserStartupError({
     elapsedMs: Math.max(0, Math.round(performance.now() - startedAt)),
     exitCode: options.child.exitCode,
     signalCode: options.child.signalCode,
-    stderr: boundedStderr(options.stderr()),
+    stderr: options.stderr(),
 }, state.failure === "spawn-error" ? { cause: state.cause } : undefined);
 const readDevtoolsPort = async (path) => {
     try {
@@ -83,6 +83,5 @@ const readDevtoolsPort = async (path) => {
         return null;
     }
 };
-const boundedStderr = (stderr) => stderr.length <= 65_536 ? stderr : stderr.slice(-65_536);
 const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 const browserStartupMessage = (failure, diagnostics) => `Chrome CDP startup ${failure}; executable=${diagnostics.executable}; elapsed_ms=${String(diagnostics.elapsedMs)}; exit_code=${diagnostics.exitCode === null ? "null" : String(diagnostics.exitCode)}; signal=${diagnostics.signalCode ?? "null"}; stderr=${diagnostics.stderr.length === 0 ? "<empty>" : diagnostics.stderr}`;

package/dist/browser/CdpAuthorizedMainFrame.js

@@ -0,0 +1,16 @@
+import { BrowserObservationError } from "../domain/errors.js";
+import { mainFrameUrl } from "./CdpCaptureDocuments.js";
+import { allowedSanitizedUrl, delayWithCancellation, isHttpUrl, } from "./CdpCaptureValues.js";
+/** Wait for the attached target's main frame to enter its approved origin. */
+export const authorizedMainFrame = async ({ connection, sessionId, signal, allowedOrigins, delayOperation, }) => {
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+        const result = await connection.send("Page.getFrameTree", {}, sessionId, signal);
+        const url = mainFrameUrl(result);
+        if (allowedSanitizedUrl(url, allowedOrigins) !== undefined)
+            return result;
+        if (isHttpUrl(url))
+            throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+        await delayWithCancellation(25, delayOperation, signal);
+    }
+    throw new BrowserObservationError("inspect_web_page", "target_not_allowed");
+};

package/dist/browser/CdpBrowserProvider.js

@@ -33,19 +33,9 @@ export class CdpBrowserProvider {
             const discovery = await discoverCdpEndpoint(input.cdp_endpoint, "list_browser_targets", options.signal);
             const allowedOrigins = new Set(input.allowed_origins);
             const selected = selectTargets(discovery, allowedOrigins);
-            const items = selected.allowed.slice(input.offset, input.offset + input.limit);
-            const nextOffset = input.offset + items.length;
             return ok(browserTargetListSchema.parse({
-                schema_version: 1,
                 browser: discovery.version,
-                targets: {
-                    items,
-                    offset: input.offset,
-                    limit: input.limit,
-                    total: selected.allowed.length,
-                    next_offset: nextOffset < selected.allowed.length ? nextOffset : null,
-                    has_more: nextOffset < selected.allowed.length,
-                },
+                targets: selected.allowed,
                 excluded: selected.excluded,
                 limitations: [
                     "Only page targets whose current URL matches an approved exact origin are listed.",
@@ -76,7 +66,7 @@ export class CdpBrowserProvider {
             const sourceMaps = input.fetch_source_maps
                 ? await fetchWebSourceMaps(captured.sourceMapRequests, input, options.signal)
                 : undefined;
-            return ok(webBundleAnalysisSchema.parse(analyzeCapturedWebBundle(captured.inspection, input, sourceMaps)));
+            return ok(webBundleAnalysisSchema.parse(analyzeCapturedWebBundle(captured.inspection, sourceMaps)));
         }
         catch (cause) {
             return err(providerError(cause, "analyze_web_bundle"));
@@ -228,7 +218,7 @@ const selectTargets = (discovery, allowedOrigins) => {
         allowed.push({
             target_id: target.id,
             type: target.type,
-            title: target.title.slice(0, 16_384),
+            title: target.title,
             url: url.url,
             origin: url.origin,
             attached: target.attached,

package/dist/browser/CdpCanonicalJsonDigest.js

@@ -0,0 +1,9 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+/** Hash a value using the canonical JSON representation. */
+export const canonicalJsonDigest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Expected canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/browser/CdpCaptureDocuments.js

@@ -1,17 +1,16 @@
-import { allowedSanitizedUrl, boundedText, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
+import { allowedSanitizedUrl, numberValue, recordValue, recordsValue, requiredRecord, stringValue, } from "./CdpCaptureValues.js";
 import { exclusionReasonForUrl } from "./CdpCaptureEventHelpers.js";
-/** Normalize allowed frames while retaining a bounded prefix and total count. */
+/** Normalize every allowed frame, optionally selecting a leading frame. */
 export const captureFrames = (result, allowedOrigins, maximum, completeness) => {
     const root = recordValue(requiredRecord(result).frameTree);
     if (root === undefined)
-        return { total: 0, items: [] };
+        return { items: [] };
     const items = [];
-    let total = 0;
     for (const tree of walkFrameTrees(root)) {
         const frame = recordValue(tree.frame);
         const frameId = stringValue(frame?.id);
         const sanitized = allowedSanitizedUrl(frame?.url, allowedOrigins);
-        if (frame === undefined || frameId === undefined || frameId.length > 256) {
+        if (frame === undefined || frameId === undefined) {
             completeness?.exclude("frames", "invalid_protocol_value");
             continue;
         }
@@ -19,27 +18,25 @@ export const captureFrames = (result, allowedOrigins, maximum, completeness) =>
             completeness?.exclude("frames", exclusionReasonForUrl(stringValue(frame.url)));
             continue;
         }
-        total += 1;
-        if (items.length >= maximum)
+        if (maximum !== undefined && items.length >= maximum)
             continue;
         items.push({
             frame_id: frameId,
-            parent_frame_id: (stringValue(frame.parentId) ?? "").slice(0, 256) || null,
+            parent_frame_id: stringValue(frame.parentId) ?? null,
             url: sanitized.url,
             origin: sanitized.origin,
         });
     }
-    return { total, items };
+    return { items };
 };
 /** Read the current main-frame URL from an untrusted Page.getFrameTree result. */
 export const mainFrameUrl = (result) => stringValue(recordValue(recordValue(requiredRecord(result).frameTree)?.frame)?.url);
-/** Normalize allowed resources while retaining a bounded prefix and total count. */
-export const captureResources = (result, allowedOrigins, maximum, completeness) => {
+/** Normalize every allowed resource. */
+export const captureResources = (result, allowedOrigins, completeness) => {
     const root = recordValue(requiredRecord(result).frameTree);
     if (root === undefined)
-        return { total: 0, items: [] };
+        return { items: [] };
     const items = [];
-    let total = 0;
     for (const tree of walkFrameTrees(root)) {
         for (const resource of recordsValue(tree.resources)) {
             const url = allowedSanitizedUrl(resource.url, allowedOrigins);
@@ -47,21 +44,18 @@ export const captureResources = (result, allowedOrigins, maximum, completeness)
                 completeness?.exclude("resources", exclusionReasonForUrl(stringValue(resource.url)));
                 continue;
             }
-            total += 1;
-            if (items.length >= maximum)
-                continue;
             const contentSize = numberValue(resource.contentSize);
             items.push({
                 rawUrl: stringValue(resource.url) ?? "",
                 url: url.url,
                 origin: url.origin,
-                type: (stringValue(resource.type) ?? "Other").slice(0, 100),
-                mime_type: (stringValue(resource.mimeType) ?? "").slice(0, 256),
+                type: stringValue(resource.type) ?? "Other",
+                mime_type: stringValue(resource.mimeType) ?? "",
                 content_size: contentSize === undefined ? null : Math.max(0, contentSize),
             });
         }
     }
-    return { total, items };
+    return { items };
 };
 const walkFrameTrees = function* (root) {
     const pending = [root];
@@ -106,11 +100,11 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
             : [];
         const baseIndex = nodes.length;
         total += nodeTypes.length;
-        for (let index = 0; index < nodeTypes.length && nodes.length < input.limits.max_dom_nodes; index += 1) {
+        for (let index = 0; index < nodeTypes.length; index += 1) {
             const attributeIndexes = numberArray(attributes[index]);
             const parent = Math.trunc(parents[index] ?? -1);
             const nodeIndex = nodes.length;
-            const nodeName = indexedString(strings, nodeNames[index]).slice(0, 256);
+            const nodeName = indexedString(strings, nodeNames[index]);
             nodes.push({
                 index: nodeIndex,
                 parent_index: parent < 0 ? -1 : baseIndex + parent,
@@ -119,8 +113,7 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                 node_value_length: indexedString(strings, nodeValues[index]).length,
                 attribute_names: attributeIndexes
                     .filter((_value, attributeIndex) => attributeIndex % 2 === 0)
-                    .map((value) => indexedString(strings, value).slice(0, 256))
-                    .slice(0, 200),
+                    .map((value) => indexedString(strings, value)),
             });
             const metadata = domMetadata({
                 strings,
@@ -131,10 +124,6 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
                 allowedOrigins,
             });
             for (const url of metadata.urls) {
-                if (urls.length >= input.limits.max_resources) {
-                    completeness?.truncate("metadata");
-                    continue;
-                }
                 urls.push(url);
                 if (url.destination_scope !== "approved") {
                     excludedUrls += 1;
@@ -150,20 +139,18 @@ export const captureDom = (result, allowedOrigins, input, completeness) => {
         total,
         nodes,
         urls,
-        agentHints: agentHints.slice(0, input.limits.max_resources),
+        agentHints,
         excludedUrls,
     };
 };
-export const captureAccessibility = (results, maximum, options) => {
+export const captureAccessibility = (results, options) => {
     const all = results.flatMap((result) => recordsValue(requiredRecord(result).nodes));
     const nodeIds = new Set(all.flatMap((node) => {
         const nodeId = stringValue(node.nodeId);
         return nodeId === undefined ? [] : [nodeId];
     }));
-    let retainedBytes = 0;
     let excludedFields = 0;
-    let truncatedFields = 0;
-    const nodes = all.slice(0, maximum).map((node) => {
+    const nodes = all.map((node) => {
         const captureText = (value) => {
             const raw = stringValue(recordValue(value)?.value);
             if (raw === undefined)
@@ -172,21 +159,11 @@ export const captureAccessibility = (results, maximum, options) => {
                 excludedFields += 1;
                 return null;
             }
-            const available = Math.max(0, options.maximumTotalBytes - retainedBytes);
-            const captured = boundedUtf8(raw, Math.min(options.maximumFieldBytes, available));
-            retainedBytes += captured.bytes;
-            if (captured.truncated) {
-                truncatedFields += 1;
-                if (captured.text === "" && raw !== "") {
-                    excludedFields += 1;
-                    return null;
-                }
-            }
-            return captured.text;
+            return raw;
         };
         return {
-            node_id: (stringValue(node.nodeId) ?? "").slice(0, 256),
-            parent_id: (stringValue(node.parentId) ?? "").slice(0, 256) || null,
+            node_id: stringValue(node.nodeId) ?? "",
+            parent_id: stringValue(node.parentId) ?? null,
             role: axText(node.role),
             name: captureText(node.name),
             description: captureText(node.description),
@@ -194,15 +171,6 @@ export const captureAccessibility = (results, maximum, options) => {
             states: accessibilityStates(node.properties),
         };
     });
-    for (const node of all.slice(maximum)) {
-        for (const value of [node.name, node.description]) {
-            if (stringValue(recordValue(value)?.value) === undefined)
-                continue;
-            excludedFields += 1;
-            if (options.includeText)
-                truncatedFields += 1;
-        }
-    }
     return {
         total: all.length,
         nodes,
@@ -216,12 +184,11 @@ export const captureAccessibility = (results, maximum, options) => {
                 ? "unavailable"
                 : !options.includeText
                     ? "not_approved"
-                    : truncatedFields > 0
-                        ? "truncated"
-                        : "included",
-            retained_bytes: retainedBytes,
+                    : "included",
+            retained_bytes: nodes.reduce((total, node) => total +
+                Buffer.byteLength(node.name ?? "") +
+                Buffer.byteLength(node.description ?? ""), 0),
             excluded_fields: excludedFields,
-            truncated_fields: truncatedFields,
         },
     };
 };
@@ -263,7 +230,7 @@ const accessibilityStates = (value) => {
             : typeof raw === "number"
                 ? numberValue(raw)
                 : typeof raw === "string"
-                    ? raw.slice(0, 256)
+                    ? raw
                     : undefined;
         if (state !== undefined)
             states.set(name, state);
@@ -272,7 +239,7 @@ const accessibilityStates = (value) => {
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([name, state]) => ({ name, value: state }));
 };
-const axText = (value) => boundedText(recordValue(value)?.value, 1_024);
+const axText = (value) => stringValue(recordValue(value)?.value) ?? null;
 const indexedString = (strings, index) => {
     const integer = numberValue(index);
     return integer === undefined ? "" : (strings[Math.trunc(integer)] ?? "");
@@ -335,21 +302,6 @@ const domDestination = (value, documentUrl, allowedOrigins) => {
         return { url: null, scope: "unsupported" };
     }
 };
-const boundedUtf8 = (value, maximumBytes) => {
-    const total = Buffer.byteLength(value);
-    if (total <= maximumBytes)
-        return { text: value, bytes: total, truncated: false };
-    let text = "";
-    let bytes = 0;
-    for (const character of value) {
-        const characterBytes = Buffer.byteLength(character);
-        if (bytes + characterBytes > maximumBytes)
-            break;
-        text += character;
-        bytes += characterBytes;
-    }
-    return { text, bytes, truncated: true };
-};
 const domUrlAttributes = [
     "href",
     "src",

package/dist/browser/CdpCaptureEventBodyShapes.js

@@ -15,8 +15,8 @@ export const ingestResponseBodyShape = (state, requestId, value) => {
         invalidResponseBodyShape(state, requestId);
         return;
     }
-    const inferred = inferBodyShape(state, decoded);
-    updateResponseBodyShape(state, requestId, inferred.shape, inferred.truncated);
+    const inferred = inferBodyShape(decoded);
+    updateResponseBodyShape(state, requestId, inferred.shape);
 };
 export const requestBodyShape = (state, request) => {
     if (!state.input.include_json_body_shapes)
@@ -24,52 +24,32 @@ export const requestBodyShape = (state, request) => {
     const body = stringValue(request.postData);
     if (!isJsonContentType(recordValue(request.headers)) || body === undefined)
         return { status: "unavailable", request: null, response: null };
-    const inferred = inferBodyShape(state, body);
+    const inferred = inferBodyShape(body);
     return {
-        status: inferred.truncated
-            ? "truncated"
-            : inferred.shape === null
-                ? "unavailable"
-                : "included",
+        status: inferred.shape === null ? "unavailable" : "included",
         request: inferred.shape,
         response: null,
     };
 };
-export const updateResponseBodyShape = (state, requestId, response, truncated) => {
+export const updateResponseBodyShape = (state, requestId, response) => {
     const current = state.network.get(requestId);
     if (current === undefined)
         return;
     const request = current.body_shapes.request;
-    const status = truncated || current.body_shapes.status === "truncated"
-        ? "truncated"
-        : response !== null
-            ? "included"
-            : request !== null
-                ? "partial"
-                : "unavailable";
+    const status = response !== null
+        ? "included"
+        : request !== null
+            ? "partial"
+            : "unavailable";
     state.network.set(requestId, {
         ...current,
         body_shapes: { status, request, response },
     });
 };
-const inferBodyShape = (state, text) => {
-    const bytes = Buffer.byteLength(text);
-    const remaining = state.input.limits.max_total_json_body_bytes - state.jsonBodyBytes;
-    if (bytes > state.input.limits.max_json_body_bytes || bytes > remaining) {
-        state.completeness.truncate("json_body_shapes");
-        return { shape: null, truncated: true };
-    }
-    state.jsonBodyBytes += bytes;
-    const shape = inferJsonShape(text, {
-        maximumBytes: state.input.limits.max_json_body_bytes,
-        maximumNodes: state.input.limits.max_json_shape_nodes,
-        maximumDepth: state.input.limits.max_json_shape_depth,
-    });
-    if (shape?.truncated === true)
-        state.completeness.truncate("json_body_shapes");
-    return { shape, truncated: shape?.truncated === true };
+const inferBodyShape = (text) => {
+    return { shape: inferJsonShape(text) };
 };
 const invalidResponseBodyShape = (state, requestId) => {
-    updateResponseBodyShape(state, requestId, null, false);
+    updateResponseBodyShape(state, requestId, null);
     state.completeness.exclude("json_body_shapes", "invalid_protocol_value");
 };