rea-agents 3.1.0 → 3.2.1

package/dist/browser/PlaywrightScenarioArtifacts.js

@@ -2,57 +2,21 @@ import { createHash } from "node:crypto";
 import { z } from "zod";
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserStepArtifactsSchema, } from "../domain/browserScenarioCapture.js";
-const TEXT_ARTIFACT_MAX_BYTES = 1_048_576;
 const historyValueSchema = z.strictObject({
     length: z.number().int().min(0),
-    navigation_entries: z
-        .array(z.strictObject({
+    navigation_entries: z.array(z.strictObject({
         type: z.string(),
         name: z.string(),
-    }))
-        .max(10_000),
+    })),
 });
 const storageValueSchema = z.strictObject({
-    local_storage: z.array(z.tuple([z.string(), z.string()])).max(10_000),
-    session_storage: z.array(z.tuple([z.string(), z.string()])).max(10_000),
+    local_storage: z.array(z.tuple([z.string(), z.string()])),
+    session_storage: z.array(z.tuple([z.string(), z.string()])),
 });
-/** Shared retained-count budget for one scenario's screenshot artifacts. */
-export class BrowserScenarioCaptureBudget {
-    maximumScreenshots;
-    maximumMetadataBytes;
-    screenshotCount = 0;
-    metadataBytes = 0;
-    constructor(maximumScreenshots, maximumMetadataBytes) {
-        this.maximumScreenshots = maximumScreenshots;
-        this.maximumMetadataBytes = maximumMetadataBytes;
-    }
-    claimScreenshot() {
-        if (this.screenshotCount >= this.maximumScreenshots)
-            return false;
-        this.screenshotCount += 1;
-        return true;
-    }
-    claimMetadata(bytes) {
-        if (this.metadataBytes + bytes > this.maximumMetadataBytes)
-            return false;
-        this.metadataBytes += bytes;
-        return true;
-    }
-}
 const notRequested = () => ({ state: "not_requested" });
 const missing = (reason) => ({ state: "missing", reason });
-const truncated = (observed, retained, reason) => ({
-    state: "truncated",
-    observed,
-    retained,
-    reason,
-});
-const textArtifact = (text, maximumBytes, budget) => {
+const textArtifact = (text) => {
     const bytes = Buffer.from(text);
-    if (bytes.byteLength > maximumBytes)
-        return truncated(bytes.byteLength, 0, `artifact exceeds ${maximumBytes} bytes`);
-    if (!budget.claimMetadata(bytes.byteLength))
-        return truncated(bytes.byteLength, 0, "scenario metadata byte limit reached");
     return {
         state: "captured",
         value: {
@@ -62,15 +26,7 @@ const textArtifact = (text, maximumBytes, budget) => {
         },
     };
 };
-const metadataArtifact = (value, budget) => {
-    const bytes = Buffer.byteLength(JSON.stringify(value));
-    return budget.claimMetadata(bytes)
-        ? { state: "captured", value }
-        : truncated(bytes, 0, "scenario metadata byte limit reached");
-};
-const captureScreenshot = async (page, scenario, budget) => {
-    if (!budget.claimScreenshot())
-        return truncated(1, 0, "scenario screenshot count limit reached");
+const captureScreenshot = async (page) => {
     try {
         const bytes = await page.screenshot({
             type: "png",
@@ -78,13 +34,10 @@ const captureScreenshot = async (page, scenario, budget) => {
             animations: "disabled",
             caret: "hide",
         });
-        if (bytes.byteLength > scenario.limits.max_screenshot_bytes)
-            return truncated(bytes.byteLength, 0, "screenshot byte limit reached");
         const sha256 = createHash("sha256").update(bytes).digest("hex");
         return {
             state: "captured",
             value: {
-                uri: `rea://web-screenshot/sha256/${sha256}`,
                 sha256,
                 bytes: bytes.byteLength,
                 media_type: "image/png",
@@ -97,25 +50,19 @@ const captureScreenshot = async (page, scenario, budget) => {
     }
 };
 const captureDom = async (input) => {
-    const { page, secrets, maximumBytes, maximumNodes, budget } = input;
+    const { page, secrets } = input;
     try {
-        const nodes = await page.locator("*").count();
-        if (nodes > maximumNodes)
-            return truncated(nodes, 0, "DOM node limit reached");
-        return textArtifact(secrets.redact(await page.content()), Math.min(maximumBytes, TEXT_ARTIFACT_MAX_BYTES), budget);
+        return textArtifact(secrets.redact(await page.content()));
     }
     catch {
         return missing("DOM capture failed");
     }
 };
 const captureAccessibility = async (input) => {
-    const { page, secrets, maximumBytes, maximumNodes, budget } = input;
+    const { page, secrets } = input;
     try {
         const text = await page.locator("html").ariaSnapshot();
-        const nodes = text.split("\n").filter((line) => line.trim() !== "").length;
-        if (nodes > maximumNodes)
-            return truncated(nodes, 0, "accessibility node limit reached");
-        return textArtifact(secrets.redact(text), Math.min(maximumBytes, TEXT_ARTIFACT_MAX_BYTES), budget);
+        return textArtifact(secrets.redact(text));
     }
     catch {
         return missing("accessibility capture failed");
@@ -132,7 +79,7 @@ const navigationType = (value) => {
             return "unknown";
     }
 };
-const captureHistory = async (page, budget) => {
+const captureHistory = async (page) => {
     try {
         const raw = historyValueSchema.parse(await page.evaluate(`(() => ({
         length: window.history.length,
@@ -143,8 +90,6 @@ const captureHistory = async (page, budget) => {
           })
         )
       }))()`));
-        if (raw.navigation_entries.length > 256)
-            return truncated(raw.navigation_entries.length, 0, "navigation history entry limit reached");
         const value = {
             length: raw.length,
             current_url: sanitizeBrowserUrl(page.url()),
@@ -153,25 +98,20 @@ const captureHistory = async (page, budget) => {
                 name: sanitizeBrowserUrl(name),
             })),
         };
-        return metadataArtifact(value, budget);
+        return { state: "captured", value };
     }
     catch {
         return missing("history capture failed");
     }
 };
 const captureStorage = async (input) => {
-    const { context, page, scenario, secrets, budget } = input;
+    const { context, page, scenario, secrets } = input;
     try {
         const cookies = await context.cookies(scenario.allowed_origins);
         const pageStorage = storageValueSchema.parse(await page.evaluate(`(() => ({
         local_storage: Object.entries(window.localStorage),
         session_storage: Object.entries(window.sessionStorage)
       }))()`));
-        const observed = cookies.length +
-            pageStorage.local_storage.length +
-            pageStorage.session_storage.length;
-        if (observed > scenario.limits.max_storage_entries)
-            return truncated(observed, 0, "storage entry limit reached");
         const value = {
             cookies: cookies.map((cookie) => ({
                 name: cookie.name,
@@ -191,7 +131,7 @@ const captureStorage = async (input) => {
                 ...secrets.fingerprint(value),
             })),
         };
-        return metadataArtifact(value, budget);
+        return { state: "captured", value };
     }
     catch {
         return missing("storage capture failed");
@@ -207,7 +147,7 @@ const isAllowedPage = (page, allowedOrigins) => {
 };
 /** Capture selected step artifacts without retaining data after scope loss. */
 export const capturePlaywrightStepArtifacts = async (input) => {
-    const { context, page, scenario, secrets, requested, budget } = input;
+    const { context, page, scenario, secrets, requested } = input;
     const allowed = isAllowedPage(page, new Set(scenario.allowed_origins));
     const denied = () => missing("current page is outside approved origins");
     const state = (kind, capture) => !requested.has(kind)
@@ -216,23 +156,14 @@ export const capturePlaywrightStepArtifacts = async (input) => {
             ? capture()
             : Promise.resolve(denied());
     return browserStepArtifactsSchema.parse({
-        screenshot: await state("screenshot", () => captureScreenshot(page, scenario, budget)),
-        dom: await state("dom", () => captureDom({
-            page,
-            secrets,
-            maximumBytes: scenario.limits.max_total_metadata_bytes,
-            maximumNodes: scenario.limits.max_dom_nodes,
-            budget,
-        })),
-        accessibility: await state("accessibility", () => captureAccessibility({
-            page,
-            secrets,
-            maximumBytes: scenario.limits.max_total_metadata_bytes,
-            maximumNodes: scenario.limits.max_accessibility_nodes,
-            budget,
+        screenshot: await state("screenshot", () => captureScreenshot(page)),
+        dom: await state("dom", () => captureDom({ page, secrets })),
+        accessibility: await state("accessibility", () => captureAccessibility({ page, secrets })),
+        url: await state("url", async () => ({
+            state: "captured",
+            value: sanitizeBrowserUrl(page.url()),
         })),
-        url: await state("url", async () => metadataArtifact(sanitizeBrowserUrl(page.url()), budget)),
-        history: await state("history", () => captureHistory(page, budget)),
-        storage: await state("storage", () => captureStorage({ context, page, scenario, secrets, budget })),
+        history: await state("history", () => captureHistory(page)),
+        storage: await state("storage", () => captureStorage({ context, page, scenario, secrets })),
     });
 };

package/dist/browser/PlaywrightScenarioBrowser.js

@@ -79,11 +79,9 @@ const configureAttachedEnvironment = async (context, page, scenario) => {
         await session.detach();
     }
 };
-export const openPlaywrightScenarioBrowser = async (scenario, environment, maximumTimeoutMs) => {
+export const openPlaywrightScenarioBrowser = async (scenario, environment) => {
     if (scenario.browser.mode === "connect") {
-        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, {
-            timeout: Math.min(scenario.limits.navigation_timeout_ms, maximumTimeoutMs),
-        });
+        const browser = await chromium.connectOverCDP(scenario.browser.cdp_endpoint, { timeout: 0 });
         try {
             const target = await findConnectedPage(browser, scenario.browser.target_id, new Set(scenario.allowed_origins));
             await configureAttachedEnvironment(target.context, target.page, scenario);
@@ -115,7 +113,7 @@ export const openPlaywrightScenarioBrowser = async (scenario, environment, maxim
             handleSIGHUP: false,
             handleSIGINT: false,
             handleSIGTERM: false,
-            timeout: maximumTimeoutMs,
+            timeout: 0,
         });
         const browser = context.browser();
         if (browser === null) {

package/dist/browser/PlaywrightScenarioEvents.js

@@ -1,40 +1,16 @@
 import { sanitizeBrowserUrl } from "../domain/browserObservation.js";
 import { browserScenarioEventSchema, } from "../domain/browserScenarioCapture.js";
-/** Bounded, arrival-ordered Playwright event capture with current-step attribution. */
+/** Arrival-ordered Playwright event capture with current-step attribution. */
 export class PlaywrightScenarioEvents {
     items = [];
-    truncated = new Set();
-    admitted = {
-        frames: new WeakSet(),
-        workers: new WeakSet(),
-        popups: new WeakSet(),
-        websockets: new WeakSet(),
-    };
-    rejected = {
-        frames: new WeakSet(),
-        workers: new WeakSet(),
-        popups: new WeakSet(),
-        websockets: new WeakSet(),
-    };
-    counts = {
-        frames: 0,
-        workers: 0,
-        popups: 0,
-        websockets: 0,
-    };
-    dropped = 0;
     stepIndex = 0;
     sequence = 0;
     enabled;
-    limits;
     secrets;
-    budget;
     allowedOrigins;
     constructor(options) {
         this.enabled = options.enabled;
-        this.limits = options.limits;
         this.secrets = options.secrets;
-        this.budget = options.budget;
         this.allowedOrigins = new Set(options.allowedOrigins);
         this.observePage(options.page);
     }
@@ -50,49 +26,19 @@ export class PlaywrightScenarioEvents {
     result() {
         return {
             retained: this.items.length,
-            dropped: this.dropped,
+            dropped: 0,
             items: this.items,
         };
     }
-    truncationSections() {
-        return [...this.truncated].sort();
-    }
     push(event) {
         this.sequence += 1;
-        if (this.items.length >= this.limits.max_events) {
-            this.dropped += 1;
-            this.truncated.add("events");
-            return;
-        }
         const parsed = browserScenarioEventSchema.parse({
             ...event,
             sequence: this.sequence,
             step_index: this.stepIndex,
         });
-        if (!this.budget.claimMetadata(Buffer.byteLength(JSON.stringify(parsed)))) {
-            this.dropped += 1;
-            this.truncated.add("events");
-            return;
-        }
         this.items.push(parsed);
     }
-    admit(section, value, maximum) {
-        if (this.admitted[section].has(value))
-            return true;
-        if (this.rejected[section].has(value))
-            return false;
-        if (this.counts[section] >= maximum) {
-            this.rejected[section].add(value);
-            this.sequence += 1;
-            this.dropped += 1;
-            this.truncated.add("events");
-            this.truncated.add(section);
-            return false;
-        }
-        this.admitted[section].add(value);
-        this.counts[section] += 1;
-        return true;
-    }
     observePage(page) {
         if (this.enabled.has("console"))
             page.on("console", (message) => {
@@ -104,10 +50,10 @@ export class PlaywrightScenarioEvents {
                 if (this.pageInScope(page))
                     this.push({
                         kind: "page-error",
-                        message: this.secrets.redact(error.message).slice(0, 65_536),
+                        message: this.secrets.redact(error.message),
                         stack: error.stack === undefined
                             ? null
-                            : this.secrets.redact(error.stack).slice(0, 262_144),
+                            : this.secrets.redact(error.stack),
                     });
             });
         if (this.enabled.has("network")) {
@@ -174,47 +120,51 @@ export class PlaywrightScenarioEvents {
         const location = message.location();
         this.push({
             kind: "console",
-            level: this.secrets.redact(message.type()).slice(0, 64),
-            text: this.secrets.redact(message.text()).slice(0, 65_536),
+            level: this.secrets.redact(message.type()),
+            text: this.secrets.redact(message.text()),
             url: location.url === "" ? null : this.safeUrl(location.url),
         });
     }
     request(kind, request) {
+        const observation = {
+            method: this.secrets.redact(request.method()),
+            url: this.safeUrl(request.url()),
+            resource_type: this.secrets.redact(request.resourceType()),
+            header_names: Object.keys(request.headers())
+                .map((name) => this.secrets.redact(name))
+                .sort(),
+        };
+        if (kind === "request-failed") {
+            this.push({
+                ...observation,
+                kind,
+                status: null,
+                failure: this.secrets.redact(request.failure()?.errorText ?? "unknown"),
+            });
+            return;
+        }
         this.push({
+            ...observation,
             kind,
-            method: this.secrets.redact(request.method()).slice(0, 32),
-            url: this.safeUrl(request.url()),
-            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
             status: null,
-            header_names: Object.keys(request.headers())
-                .map((name) => this.secrets.redact(name).slice(0, 256))
-                .sort()
-                .slice(0, 256),
-            failure: kind === "request-failed"
-                ? this.secrets
-                    .redact(request.failure()?.errorText ?? "unknown")
-                    .slice(0, 1_024)
-                : null,
+            failure: null,
         });
     }
     response(response) {
         const request = response.request();
         this.push({
             kind: "response",
-            method: this.secrets.redact(request.method()).slice(0, 32),
+            method: this.secrets.redact(request.method()),
             url: this.safeUrl(response.url()),
-            resource_type: this.secrets.redact(request.resourceType()).slice(0, 64),
+            resource_type: this.secrets.redact(request.resourceType()),
             status: response.status(),
             header_names: Object.keys(response.headers())
-                .map((name) => this.secrets.redact(name).slice(0, 256))
-                .sort()
-                .slice(0, 256),
+                .map((name) => this.secrets.redact(name))
+                .sort(),
             failure: null,
         });
     }
     webSocket(page, socket) {
-        if (!this.admit("websockets", socket, this.limits.max_websockets))
-            return;
         const url = this.safeUrl(socket.url());
         this.push({ kind: "websocket-opened", url });
         socket.on("framesent", ({ payload }) => {
@@ -233,30 +183,35 @@ export class PlaywrightScenarioEvents {
     webSocketFrame(kind, url, payload) {
         const bytes = Buffer.byteLength(payload);
         const isText = typeof payload === "string";
-        const text = isText ? this.secrets.redact(payload).slice(0, 65_536) : null;
+        if (!isText) {
+            this.push({
+                kind,
+                url,
+                payload_type: "binary",
+                payload_bytes: bytes,
+                payload_text: null,
+                truncated: false,
+            });
+            return;
+        }
+        const text = this.secrets.redact(payload);
         this.push({
             kind,
             url,
-            payload_type: isText ? "text" : "binary",
+            payload_type: "text",
             payload_bytes: bytes,
             payload_text: text,
-            truncated: isText && text !== null && text.length < payload.length,
+            truncated: false,
         });
     }
     frame(kind, frame) {
-        if (!this.admit("frames", frame, this.limits.max_frames))
-            return;
         this.push({
             kind,
             url: frame.url() === "" ? null : this.safeUrl(frame.url()),
-            name: frame.name() === ""
-                ? null
-                : this.secrets.redact(frame.name()).slice(0, 1_024),
+            name: frame.name() === "" ? null : this.secrets.redact(frame.name()),
         });
     }
     worker(page, worker) {
-        if (!this.admit("workers", worker, this.limits.max_workers))
-            return;
         const details = {
             url: this.safeUrl(worker.url()),
             name: null,
@@ -272,8 +227,6 @@ export class PlaywrightScenarioEvents {
             void page.close().catch(() => undefined);
             return;
         }
-        if (!this.admit("popups", page, this.limits.max_popups))
-            return;
         const opened = {
             url: page.url() === "" ? null : this.safeUrl(page.url()),
             name: null,
@@ -291,9 +244,7 @@ export class PlaywrightScenarioEvents {
     download(download) {
         this.push({
             kind: "download-cancelled",
-            suggested_filename: this.secrets
-                .redact(download.suggestedFilename())
-                .slice(0, 1_024),
+            suggested_filename: this.secrets.redact(download.suggestedFilename()),
             url: this.safeUrl(download.url()),
         });
         void download.cancel().catch(() => undefined);

package/dist/browser/PlaywrightScenarioSession.js

@@ -3,7 +3,7 @@ import { BrowserObservationError } from "../domain/errors.js";
 import { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
 import { closePlaywrightScenarioBrowser, openPlaywrightScenarioBrowser, } from "./PlaywrightScenarioBrowser.js";
 import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
-import { BrowserScenarioCaptureBudget, capturePlaywrightStepArtifacts, } from "./PlaywrightScenarioArtifacts.js";
+import { capturePlaywrightStepArtifacts } from "./PlaywrightScenarioArtifacts.js";
 import { PlaywrightScenarioEvents } from "./PlaywrightScenarioEvents.js";
 import { withPlaywrightExecutionBoundary } from "./PlaywrightExecutionBoundary.js";
 const OPERATION = "capture_browser_scenario";
@@ -133,8 +133,8 @@ const blockAttachedServiceWorkers = async (page) => {
     await page.evaluate(blockRegistration);
 };
 const initializePage = async (context, page, scenario, secrets) => {
-    context.setDefaultTimeout(scenario.limits.action_timeout_ms);
-    context.setDefaultNavigationTimeout(scenario.limits.navigation_timeout_ms);
+    context.setDefaultTimeout(0);
+    context.setDefaultNavigationTimeout(0);
     const ownedPages = new Set([page]);
     if (scenario.browser.mode === "connect")
         await blockAttachedServiceWorkers(page);
@@ -190,16 +190,15 @@ export class PlaywrightScenarioSession {
         this.initialUrl = opened.page.url();
     }
     static async open(scenario, environment, options) {
-        const remaining = () => options.deadlineAt - Date.now();
         if (options.signal?.aborted === true)
             throw new BrowserObservationError(OPERATION, "cancelled");
         const secrets = BrowserScenarioSecrets.resolve(scenario, environment);
         if (secrets === undefined)
             throw new BrowserObservationError(OPERATION, "secret_unavailable");
-        const opening = openPlaywrightScenarioBrowser(scenario, environment, remaining());
+        const opening = openPlaywrightScenarioBrowser(scenario, environment);
         let opened;
         try {
-            opened = await withPlaywrightExecutionBoundary(() => opening, remaining(), options.signal);
+            opened = await withPlaywrightExecutionBoundary(() => opening, undefined, options.signal);
         }
         catch (cause) {
             void opening
@@ -208,20 +207,18 @@ export class PlaywrightScenarioSession {
             throw cause;
         }
         try {
-            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), remaining(), options.signal);
+            await withPlaywrightExecutionBoundary(() => initializePage(opened.context, opened.page, scenario, secrets), undefined, options.signal);
             const events = new PlaywrightScenarioEvents({
                 page: opened.page,
                 enabled: new Set(scenario.capture.events),
-                limits: scenario.limits,
                 secrets,
-                budget: options.budget,
                 allowedOrigins: scenario.allowed_origins,
             });
             const session = new PlaywrightScenarioSession(opened, scenario, secrets, events);
             await withPlaywrightExecutionBoundary(() => opened.page.goto(secrets.url(scenario.start_url), {
                 waitUntil: "load",
-                timeout: Math.min(scenario.limits.navigation_timeout_ms, remaining()),
-            }), remaining(), options.signal);
+                timeout: 0,
+            }), undefined, options.signal);
             return session;
         }
         catch (cause) {
@@ -244,27 +241,21 @@ export class PlaywrightScenarioSession {
     events() {
         return this.eventCapture.result();
     }
-    eventTruncationSections() {
-        return this.eventCapture.truncationSections();
-    }
-    async perform(action, maximumTimeoutMs, signal) {
+    async perform(action, signal) {
         await withPlaywrightExecutionBoundary(() => performPlaywrightScenarioAction({
             page: this.opened.page,
             action,
             secrets: this.secrets,
-            defaultTimeoutMs: this.scenario.limits.action_timeout_ms,
-            maximumTimeoutMs,
-        }), maximumTimeoutMs, signal);
+        }), "timeout_ms" in action ? action.timeout_ms : undefined, signal);
     }
-    async capture(requested, budget, maximumTimeoutMs, signal) {
+    async capture(requested, signal) {
         return withPlaywrightExecutionBoundary(() => capturePlaywrightStepArtifacts({
             context: this.opened.context,
             page: this.opened.page,
             scenario: this.scenario,
             secrets: this.secrets,
             requested,
-            budget,
-        }), maximumTimeoutMs, signal);
+        }), undefined, signal);
     }
     async close() {
         if (this.closed)
@@ -278,9 +269,7 @@ export class PlaywrightScenarioSession {
             : "disconnected-external";
     }
     redactError(error) {
-        return this.secrets
-            .redact(error instanceof Error ? error.message : "browser action failed")
-            .slice(0, 4_096);
+        return this.secrets.redact(error instanceof Error ? error.message : "browser action failed");
     }
 }
 /** Production Playwright/CDP session factory. */
@@ -290,11 +279,6 @@ export class PlaywrightScenarioSessionFactory {
         this.environment = environment;
     }
     open(scenario, options = {}) {
-        return PlaywrightScenarioSession.open(scenario, this.environment, {
-            ...(options.signal === undefined ? {} : { signal: options.signal }),
-            budget: options.budget ??
-                new BrowserScenarioCaptureBudget(scenario.limits.max_screenshots, scenario.limits.max_total_metadata_bytes),
-            deadlineAt: options.deadlineAt ?? Date.now() + scenario.limits.max_duration_ms,
-        });
+        return PlaywrightScenarioSession.open(scenario, this.environment, options);
     }
 }