rea-agents 3.1.0 → 3.2.1

package/dist/application/BrowserEvidence.js

@@ -1,7 +1,7 @@
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { commitBrowserScenarioNormalization } from "../domain/browserScenarioNormalization.js";
-/** Create Evidence v2 for a policy-scoped external browser observation. */
+/** Create Evidence for a policy-scoped external browser observation. */
 export const createBrowserEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: browserPredicate(operation),
     operation,
@@ -21,99 +21,83 @@ export const createBrowserEvidence = (operation, input, result, provider) => cre
 });
 const browserParameters = (input) => {
     if (!("cdp_endpoint" in input)) {
-        if ("before_scenario" in input)
+        if ("before_scenario" in input &&
+            input.before_scenario !== undefined &&
+            input.after_scenario !== undefined)
             return {
                 comparison_kind: "browser_scenario",
                 before_browser: input.before_scenario.browser,
                 after_browser: input.after_scenario.browser,
                 before_start_origin: input.before_scenario.scenario.start_origin,
                 after_start_origin: input.after_scenario.scenario.start_origin,
-                max_changes: input.max_changes,
-                normalization_sha256: commitBrowserScenarioNormalization(input.normalization).sha256,
+                normalization_sha256: commitBrowserScenarioNormalization(input.normalization ?? { rules: [] }).sha256,
             };
-        if ("max_changes" in input)
+        if (input.before !== undefined &&
+            input.after !== undefined &&
+            "inspection" in input.before &&
+            "inspection" in input.after)
             return {
                 before_target_id: input.before.inspection.target.target_id,
                 before_capture_ended_at: input.before.inspection.capture_window.ended_at,
                 after_target_id: input.after.inspection.target.target_id,
                 after_capture_ended_at: input.after.inspection.capture_window.ended_at,
-                max_changes: input.max_changes,
             };
-        return {
-            before_artifact_uri: input.before.uri,
-            after_artifact_uri: input.after.uri,
-            channel_threshold: input.channel_threshold,
-            maximum_pixels: input.maximum_pixels,
-        };
+        if (isScreenshotComparison(input))
+            return {
+                before_artifact_sha256: input.before.sha256,
+                after_artifact_sha256: input.after.sha256,
+                channel_threshold: input.channel_threshold,
+            };
+        throw new Error("Browser comparison input did not match a comparison type");
     }
     const scope = {
         cdp_endpoint: input.cdp_endpoint,
         allowed_origins: input.allowed_origins,
     };
     if (!("target_id" in input))
-        return { ...scope, offset: input.offset, limit: input.limit };
-    if ("screenshot_approved" in input)
-        return {
-            ...scope,
-            target_id: input.target_id,
-            maximum_image_bytes: input.maximum_image_bytes,
-        };
-    if ("max_tools" in input)
-        return {
-            ...scope,
-            target_id: input.target_id,
-            observation_ms: input.observation_ms,
-            max_tools: input.max_tools,
-            max_schema_bytes: input.max_schema_bytes,
-            max_schema_nodes: input.max_schema_nodes,
-            max_schema_depth: input.max_schema_depth,
-        };
-    if (!("include_accessibility_text" in input))
-        return {
-            ...scope,
-            target_id: input.target_id,
-            observation_ms: input.observation_ms,
-            max_timeline_events: input.max_timeline_events,
-        };
+        return scope;
     return {
         ...scope,
         target_id: input.target_id,
-        observation_ms: input.observation_ms,
-        include_accessibility_text: input.include_accessibility_text,
-        include_console_text: input.include_console_text,
-        include_json_body_shapes: input.include_json_body_shapes,
-        include_websocket_shapes: input.include_websocket_shapes,
-        include_script_sources: input.include_script_sources,
-        include_storage_keys: input.include_storage_keys,
-        include_storage_fingerprints: input.include_storage_fingerprints,
-        limits: input.limits,
-        source_capture_approved: input.source_capture_approved,
-        ...(input.include_script_sources && "analysis_limits" in input
+        ...("observation_ms" in input
+            ? { observation_ms: input.observation_ms }
+            : {}),
+        ...("include_accessibility_text" in input
             ? {
-                fetch_source_maps: input.fetch_source_maps,
-                source_map_fetch_approved: input.source_map_fetch_approved,
-                analysis_limits: input.analysis_limits,
+                include_accessibility_text: input.include_accessibility_text,
+                include_console_text: input.include_console_text,
+                include_json_body_shapes: input.include_json_body_shapes,
+                include_websocket_shapes: input.include_websocket_shapes,
+                include_storage_keys: input.include_storage_keys,
+                include_storage_fingerprints: input.include_storage_fingerprints,
+                ...("include_script_sources" in input
+                    ? { include_script_sources: input.include_script_sources }
+                    : {}),
             }
             : {}),
+        ...("fetch_source_maps" in input
+            ? { fetch_source_maps: input.fetch_source_maps }
+            : {}),
     };
 };
+const isScreenshotComparison = (input) => "channel_threshold" in input;
 const browserPredicate = (operation) => {
     switch (operation) {
         case "list_browser_targets":
-            return "rea.browser-target-list/v1";
+            return "rea.browser-target-list";
         case "inspect_web_page":
-            return "rea.web-page-inspection/v2";
+            return "rea.web-page-inspection";
         case "analyze_web_bundle":
-            return "rea.web-bundle-analysis/v1";
+            return "rea.web-bundle-analysis";
         case "observe_web_session":
-            return "rea.web-observation-session/v1";
+            return "rea.web-observation-session";
         case "discover_webmcp_tools":
-            return "rea.webmcp-discovery/v1";
+            return "rea.webmcp-discovery";
         case "compare_web_captures":
-            return "rea.web-capture-diff/v1";
+            return "rea.web-capture-diff";
         case "capture_web_screenshot":
-            return "rea.web-screenshot/v1";
+            return "rea.web-screenshot";
         case "compare_web_screenshots":
-            return "rea.web-screenshot-diff/v1";
+            return "rea.web-screenshot-diff";
     }
 };

package/dist/application/BrowserObservationService.js

@@ -1,5 +1,6 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { isLiteralLoopbackHostname, } from "../domain/browserObservation.js";
-import { AnalysisCapabilityUnavailableError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { createBrowserEvidence } from "./BrowserEvidence.js";
 /** Authorize and execute one policy-scoped target discovery observation. */
@@ -96,11 +97,7 @@ const prepare = async (browser, authority, input, operation) => {
         operation_identity: `${operation}:${input.target_id ?? input.cdp_endpoint}`,
     }, "read");
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     return browser === undefined
         ? err(new AnalysisCapabilityUnavailableError("rea-cdp-browser", operation, "browser observation provider is not configured"))
         : ok(browser);

package/dist/application/BrowserScenarioCaptureService.js

@@ -1,6 +1,7 @@
+import { projectPermissionFailure } from "./PermissionFailure.js";
 import { createBrowserScenarioEvidence } from "./BrowserScenarioEvidence.js";
 import { digestJson } from "./JavaScriptReplayPlanning.js";
-import { AnalysisCapabilityUnavailableError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
 import { isLiteralLoopbackHostname } from "../domain/browserObservation.js";
 import { err } from "../domain/result.js";
 const OPERATION = "capture_browser_scenario";
@@ -29,11 +30,7 @@ const authorizeScenario = async (authority, scenario) => {
         operation_identity: `${OPERATION}:${digestJson(scenario)}`,
     }, "write");
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     return { ok: true, value: true };
 };
 /** Authorize and execute one controlled browser scenario. */

package/dist/application/BrowserScenarioEvidence.js

@@ -11,6 +11,7 @@ const browserScenarioParameters = (scenario) => ({
         step_id,
         action,
     })),
+    action_timeouts_ms: scenario.actions.map((item) => "timeout_ms" in item ? (item.timeout_ms ?? null) : null),
     secret_declarations: scenario.secrets.map(({ secret_id, environment_variable, purpose, redaction }) => ({
         secret_id,
         environment_variable,
@@ -18,11 +19,10 @@ const browserScenarioParameters = (scenario) => ({
         redaction,
     })),
     capture: scenario.capture,
-    limits: scenario.limits,
 });
-/** Create Evidence v2 without retaining resolved scenario secret values. */
+/** Create Evidence without retaining resolved scenario secret values. */
 export const createBrowserScenarioEvidence = (scenario, capture, provider) => createEvidence(undefined, provider, {
-    predicateType: "rea.browser-scenario-capture/v1",
+    predicateType: "rea.browser-scenario-capture",
     operation: "capture_browser_scenario",
     parameters: browserScenarioParameters(scenario),
     result: jsonValueSchema.parse(capture),

package/dist/application/CallPathTracing.js

@@ -1,7 +1,7 @@
 import { projectAnalysisError } from "../domain/errors.js";
 import { parseRelatedAddresses } from "../domain/hopperValues.js";
 import { ok } from "../domain/result.js";
-/** Trace one deterministic bounded direct caller/callee path. */
+/** Trace direct caller/callee relationships until the graph is exhausted or the goal is reached. */
 export const traceCallPath = async (call, input, signal) => {
     const state = createTraceState(input);
     while (state.queueIndex < state.queue.length &&
@@ -12,17 +12,6 @@ export const traceCallPath = async (call, input, signal) => {
         const current = state.visited.get(address);
         if (current === undefined)
             continue;
-        if (current.depth >= input.max_depth) {
-            state.frontier.add(address);
-            state.residual.add("Call-path traversal reached the depth limit.");
-            continue;
-        }
-        if (state.operations >= input.max_operations) {
-            recordPendingFrontier(state, input);
-            state.residual.add("Call-path traversal reached the operation budget.");
-            break;
-        }
-        state.operations += 1;
         const found = await expandAddress(call, {
             input,
             state,
@@ -40,9 +29,7 @@ const createTraceState = (input) => ({
     queue: [input.start],
     edges: new Map(),
     failures: [],
-    frontier: new Set(),
     residual: new Set(),
-    operations: 0,
     queueIndex: 0,
     traversalPath: input.goal === input.start ? [input.start] : [],
 });
@@ -85,12 +72,6 @@ const expandAddress = async (call, expansion) => {
             }
             continue;
         }
-        if (state.visited.size >= input.max_nodes) {
-            if (state.frontier.size < input.max_nodes)
-                state.frontier.add(relatedAddress);
-            state.residual.add("Call-path traversal reached the node limit.");
-            continue;
-        }
         state.visited.set(relatedAddress, {
             depth: current.depth + 1,
             path,
@@ -109,21 +90,12 @@ const recordEdge = (input, state, edge) => {
     const edgeKey = `${sourceAddress}\u0000${targetAddress}`;
     if (state.edges.has(edgeKey))
         return;
-    if (state.edges.size >= input.max_nodes) {
-        state.residual.add("Call-path traversal reached the edge limit.");
-        return;
-    }
     state.edges.set(edgeKey, {
         source_address: sourceAddress,
         target_address: targetAddress,
         discovery_depth: edge.discoveryDepth,
     });
 };
-const recordPendingFrontier = (state, input) => {
-    for (const pending of state.queue.slice(state.queueIndex - 1))
-        if (state.frontier.size < input.max_nodes)
-            state.frontier.add(pending);
-};
 const projectTrace = (input, state) => ({
     start: input.start,
     goal: input.goal ?? null,
@@ -141,19 +113,13 @@ const projectTrace = (input, state) => ({
         compareAddress(left.target_address, right.target_address)),
     traversal_path: state.traversalPath,
     failures: state.failures,
-    frontier: [...state.frontier].sort(compareAddress),
-    limits: {
-        max_depth: input.max_depth,
-        max_nodes: input.max_nodes,
-        max_operations: input.max_operations,
+    traversal: {
         nodes_visited: state.visited.size,
-        operations_used: state.operations,
     },
     truncated: state.residual.size > 0,
     residual_unknowns: [...state.residual],
     limitations: [
         "Direct provider call relationships may omit unresolved indirect calls.",
-        "A not_reached goal is only absent from this bounded traversal, not from the complete program.",
     ],
 });
 const compareAddress = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/CapabilityInventory.js

@@ -9,7 +9,12 @@ const statusSchema = z.object({
     capabilities: z.array(providerCapability),
 });
 const ENHANCED_REQUIREMENTS = {
-    swift_classes: ["list_procedures"],
+    trace_native_ui_action: [
+        "decode_interface_builder",
+        "list_names",
+        "procedure_callees",
+    ],
+    inspect_native_dispatch_metadata: ["list_names"],
     get_objc_classes: ["list_names"],
     get_objc_protocols: ["list_names"],
     batch_decompile: ["procedure_pseudo_code"],
@@ -114,14 +119,9 @@ const availabilityFor = (context) => {
         return targetDecision;
     return providerAvailability(context);
 };
-const javascriptApplicationAvailability = ({ name, policy, }) => {
+const javascriptApplicationAvailability = ({ name, }) => {
     if (name === "analyze_javascript_application")
-        return policy.investigationInputRoots === 0
-            ? {
-                reason: "policy_disabled",
-                remediation: "Configure an exact REA_INVESTIGATION_INPUT_ROOTS_JSON root in the MCP registration, then restart the registered MCP server or client.",
-            }
-            : { reason: "available", remediation: null };
+        return { reason: "available", remediation: null };
     return name === "reconcile_javascript_runtime"
         ? { reason: "available", remediation: null }
         : null;
@@ -152,11 +152,6 @@ const policyAvailability = ({ name, kind, policy, }) => {
         return { reason: "available", remediation: null };
     if (kind === "application")
         return { reason: "available", remediation: null };
-    if (name === "import_evidence_bundle" && policy.evidenceFileRoots === 0)
-        return {
-            reason: "policy_disabled",
-            remediation: "Configure or grant an evidence_read root.",
-        };
     const electron = electronPolicyAvailability(name, kind, policy);
     if (electron !== null)
         return electron;
@@ -165,7 +160,7 @@ const policyAvailability = ({ name, kind, policy, }) => {
             ? { reason: "available", remediation: null }
             : {
                 reason: "policy_disabled",
-                remediation: "Enable V8 Inspector observation and configure exact loopback endpoints plus canonical file roots or exact origins.",
+                remediation: "Enable V8 Inspector observation; pass the user's literal-loopback Inspector endpoint to the tool.",
             };
     if (kind === "session")
         return { reason: "available", remediation: null };
@@ -185,7 +180,7 @@ const electronPolicyAvailability = (name, kind, policy) => {
         ? { reason: "available", remediation: null }
         : {
             reason: "policy_disabled",
-            remediation: "Enable Electron observation and configure a loopback CDP endpoint and canonical file roots.",
+            remediation: "Enable Electron observation; pass the user's literal-loopback CDP endpoint to the tool.",
         };
 };
 const browserPolicyAvailability = (name, kind, policy) => {

package/dist/application/ClientConfigurationDocument.js

@@ -0,0 +1,27 @@
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { isDeepStrictEqual } from "node:util";
+import { z } from "zod";
+const objectSchema = z.record(z.string(), z.unknown());
+/** Compare parsed configuration values without depending on parser prototypes. */
+export const clientConfigurationValuesEqual = (left, right) => isDeepStrictEqual(normalizeConfigurationValue(left), normalizeConfigurationValue(right));
+const normalizeConfigurationValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(normalizeConfigurationValue);
+    if (typeof value !== "object" || value === null || value instanceof Date)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, nested]) => [key, normalizeConfigurationValue(nested)]));
+};
+/** Parse the client format and reject malformed root or server-table values. */
+export const parseClientConfiguration = (text, format) => {
+    const document = objectSchema.parse(format === "toml" ? parseToml(text) : JSON.parse(text));
+    const serversKey = format === "toml" ? "mcp_servers" : "mcpServers";
+    const value = document[serversKey];
+    const servers = value === undefined ? {} : objectSchema.parse(value);
+    return { document, servers, serversKey };
+};
+/** Serialize a validated client document using the selected format. */
+export const serializeClientConfiguration = (document, format) => format === "toml"
+    ? stringifyToml(document)
+    : `${JSON.stringify(document, null, 2)}\n`;

package/dist/application/ClientRegistrationStatus.js

@@ -1,11 +1,10 @@
+import { parseClientConfiguration } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { parse as parseToml } from "smol-toml";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
 import { supportedClients } from "./SupportedClients.js";
-const objectSchema = z.record(z.string(), z.unknown());
 const registrationSchema = z
     .object({
     command: z.string().min(1),
@@ -21,21 +20,23 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             continue;
         try {
             const content = await readFile(client.configPath, "utf8");
-            const document = objectSchema.parse(client.format === "toml" ? parseToml(content) : JSON.parse(content));
-            const servers = objectSchema.parse(document[client.format === "toml" ? "mcp_servers" : "mcpServers"] ?? {});
+            const { servers } = parseClientConfiguration(content, client.format);
             const raw = servers[PRODUCT_IDENTITY.mcpServerKey];
             if (raw === undefined) {
-                statuses.push(status(client.name, client.configPath, [], "missing"));
+                statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
             }
             const registration = registrationSchema.parse(raw);
-            const command = [registration.command, ...registration.args];
-            statuses.push(status(client.name, client.configPath, command, registrationAligned(registration, client.name, currentCommandPath)
+            const command = [
+                registration.command,
+                ...registration.args,
+            ];
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client.name, currentCommandPath)
                 ? "aligned"
                 : "stale"));
         }
         catch (cause) {
-            statuses.push(status(client.name, client.configPath, [], isMissing(cause) ? "missing" : "invalid"));
+            statuses.push(unavailableStatus(client.name, client.configPath, isMissing(cause) ? "missing" : "invalid"));
         }
     }
     return statuses.sort((left, right) => left.client.localeCompare(right.client));
@@ -56,14 +57,16 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         command[1] === "mcp" &&
         resolve(command[0] ?? "") === currentCommandPath);
 };
-const status = (client, configPath, command, state) => ({
+const remediation = "Run rea setup to refresh this registration, then restart the client.";
+const configuredStatus = (client, configPath, command, state) => state === "aligned"
+    ? { client, config_path: configPath, command, state, remediation: null }
+    : { client, config_path: configPath, command, state, remediation };
+const unavailableStatus = (client, configPath, state) => ({
     client,
     config_path: configPath,
-    command,
+    command: [],
     state,
-    remediation: state === "aligned"
-        ? null
-        : "Run rea setup to refresh this registration, then restart the client.",
+    remediation,
 });
 const exists = async (path) => {
     if (path === undefined)

package/dist/application/CommandShimReplay.js

@@ -2,6 +2,19 @@ import { createServer } from "node:http";
 import { chmod, mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 const RUNNER = `const command = process.argv[2];
+const maximumTimerDelay = 2147483647;
+const delay = milliseconds => new Promise(resolve => {
+  let remaining = milliseconds;
+  const schedule = () => {
+    const interval = Math.min(remaining, maximumTimerDelay);
+    setTimeout(() => {
+      remaining -= interval;
+      if (remaining === 0) resolve();
+      else schedule();
+    }, interval);
+  };
+  schedule();
+});
 const response = await fetch(process.env.REA_SHIM_LEDGER_URL, {
   method: "POST",
   headers: { "content-type": "application/json" },
@@ -12,7 +25,7 @@ const route = await response.json();
 let elapsed = 0;
 for (const output of route.outputs) {
   const wait = Math.max(0, output.at_ms - elapsed);
-  if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
+  if (wait > 0) await delay(wait);
   elapsed = output.at_ms;
   (output.stream === "stdout" ? process.stdout : process.stderr).write(output.data);
 }