rea-agents 3.0.0 → 3.2.0

package/dist/domain/browserScenarioCaptureValues.js

@@ -3,16 +3,11 @@ import { z } from "zod";
 import { sanitizedBrowserUrlSchema } from "./browserObservation.js";
 import { webScreenshotArtifactSchema } from "./webScreenshot.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().max(1_048_576);
 const textArtifactSchema = z
     .strictObject({
     sha256: digestSchema,
-    bytes: z
-        .number()
-        .int()
-        .min(0)
-        .max(16 * 1_024 * 1_024),
-    text: boundedTextSchema,
+    bytes: z.number().int().min(0),
+    text: z.string(),
 })
     .superRefine((artifact, context) => {
     const bytes = Buffer.from(artifact.text);
@@ -30,20 +25,19 @@ export const captureStateSchema = (value) => z.discriminatedUnion("state", [
     }),
     z.strictObject({
         state: z.literal("missing"),
-        reason: z.string().min(1).max(1_024),
+        reason: z.string().min(1),
     }),
     z.strictObject({
         state: z.literal("truncated"),
         observed: z.number().int().min(0),
         retained: z.number().int().min(0),
-        reason: z.string().min(1).max(1_024),
+        reason: z.string().min(1),
     }),
 ]);
 const historySchema = z.strictObject({
     length: z.number().int().min(0),
     current_url: sanitizedBrowserUrlSchema,
-    navigation_entries: z
-        .array(z.strictObject({
+    navigation_entries: z.array(z.strictObject({
         type: z.enum([
             "navigate",
             "reload",
@@ -52,29 +46,45 @@ const historySchema = z.strictObject({
             "unknown",
         ]),
         name: sanitizedBrowserUrlSchema,
-    }))
-        .max(256),
-});
-const storageValueSchema = z.strictObject({
-    name: z.string().max(1_024),
-    value_state: z.enum(["hashed", "redacted-secret"]),
-    value_sha256: digestSchema.nullable(),
+    })),
 });
+const hashedStorageValueShape = {
+    value_state: z.literal("hashed"),
+    value_sha256: digestSchema,
+};
+const redactedStorageValueShape = {
+    value_state: z.literal("redacted-secret"),
+    value_sha256: z.null(),
+};
+const storageValueFingerprintSchema = z.discriminatedUnion("value_state", [
+    z.strictObject(hashedStorageValueShape),
+    z.strictObject(redactedStorageValueShape),
+]);
+const storageValueSchema = z.discriminatedUnion("value_state", [
+    z.strictObject({
+        name: z.string(),
+        ...hashedStorageValueShape,
+    }),
+    z.strictObject({
+        name: z.string(),
+        ...redactedStorageValueShape,
+    }),
+]);
+const cookieShape = {
+    name: z.string(),
+    domain: z.string(),
+    path: z.string(),
+    secure: z.boolean(),
+    http_only: z.boolean(),
+    same_site: z.enum(["Strict", "Lax", "None"]),
+};
 const storageSnapshotSchema = z.strictObject({
-    cookies: z
-        .array(z.strictObject({
-        name: z.string().max(1_024),
-        domain: z.string().max(2_048),
-        path: z.string().max(4_096),
-        secure: z.boolean(),
-        http_only: z.boolean(),
-        same_site: z.enum(["Strict", "Lax", "None"]),
-        value_state: z.enum(["hashed", "redacted-secret"]),
-        value_sha256: digestSchema.nullable(),
-    }))
-        .max(512),
-    local_storage: z.array(storageValueSchema).max(512),
-    session_storage: z.array(storageValueSchema).max(512),
+    cookies: z.array(z.discriminatedUnion("value_state", [
+        z.strictObject({ ...cookieShape, ...hashedStorageValueShape }),
+        z.strictObject({ ...cookieShape, ...redactedStorageValueShape }),
+    ])),
+    local_storage: z.array(storageValueSchema),
+    session_storage: z.array(storageValueSchema),
 });
 export const browserStepArtifactsSchema = z.strictObject({
     screenshot: captureStateSchema(webScreenshotArtifactSchema),
@@ -89,29 +99,51 @@ const eventBase = {
     step_index: z.number().int().min(0),
 };
 const eventUrl = sanitizedBrowserUrlSchema.nullable();
-export const browserScenarioEventSchema = z.discriminatedUnion("kind", [
+const networkEventShape = {
+    ...eventBase,
+    method: z.string().min(1),
+    url: sanitizedBrowserUrlSchema,
+    resource_type: z.string().min(1),
+    header_names: z.array(z.string()),
+};
+const webSocketFrameShape = {
+    ...eventBase,
+    kind: z.enum(["websocket-frame-sent", "websocket-frame-received"]),
+    url: sanitizedBrowserUrlSchema,
+    payload_bytes: z.number().int().min(0),
+    truncated: z.boolean(),
+};
+export const browserScenarioEventSchema = z.union([
     z.strictObject({
         ...eventBase,
         kind: z.literal("console"),
-        level: z.string().min(1).max(64),
-        text: z.string().max(65_536),
+        level: z.string().min(1),
+        text: z.string(),
         url: eventUrl,
     }),
     z.strictObject({
         ...eventBase,
         kind: z.literal("page-error"),
-        message: z.string().max(65_536),
-        stack: z.string().max(262_144).nullable(),
+        message: z.string(),
+        stack: z.string().nullable(),
     }),
     z.strictObject({
-        ...eventBase,
-        kind: z.enum(["request", "response", "request-failed"]),
-        method: z.string().min(1).max(32),
-        url: sanitizedBrowserUrlSchema,
-        resource_type: z.string().min(1).max(64),
-        status: z.number().int().min(100).max(599).nullable(),
-        header_names: z.array(z.string().max(256)).max(256),
-        failure: z.string().max(1_024).nullable(),
+        ...networkEventShape,
+        kind: z.literal("request"),
+        status: z.null(),
+        failure: z.null(),
+    }),
+    z.strictObject({
+        ...networkEventShape,
+        kind: z.literal("response"),
+        status: z.number().int().min(100).max(599),
+        failure: z.null(),
+    }),
+    z.strictObject({
+        ...networkEventShape,
+        kind: z.literal("request-failed"),
+        status: z.null(),
+        failure: z.string().min(1),
     }),
     z.strictObject({
         ...eventBase,
@@ -119,13 +151,14 @@ export const browserScenarioEventSchema = z.discriminatedUnion("kind", [
         url: sanitizedBrowserUrlSchema,
     }),
     z.strictObject({
-        ...eventBase,
-        kind: z.enum(["websocket-frame-sent", "websocket-frame-received"]),
-        url: sanitizedBrowserUrlSchema,
-        payload_type: z.enum(["text", "binary"]),
-        payload_bytes: z.number().int().min(0),
-        payload_text: z.string().max(65_536).nullable(),
-        truncated: z.boolean(),
+        ...webSocketFrameShape,
+        payload_type: z.literal("text"),
+        payload_text: z.string(),
+    }),
+    z.strictObject({
+        ...webSocketFrameShape,
+        payload_type: z.literal("binary"),
+        payload_text: z.null(),
     }),
     z.strictObject({
         ...eventBase,
@@ -139,12 +172,12 @@ export const browserScenarioEventSchema = z.discriminatedUnion("kind", [
             "popup-closed",
         ]),
         url: eventUrl,
-        name: z.string().max(1_024).nullable(),
+        name: z.string().nullable(),
     }),
     z.strictObject({
         ...eventBase,
         kind: z.literal("download-cancelled"),
-        suggested_filename: z.string().max(1_024),
+        suggested_filename: z.string(),
         url: sanitizedBrowserUrlSchema,
     }),
 ]);
@@ -162,43 +195,72 @@ const completenessSectionSchema = z.enum([
     "popups",
     "websockets",
 ]);
-export const browserScenarioCompletenessSchema = z
-    .strictObject({
-    status: z.enum(["complete", "incomplete", "truncated"]),
-    equality_eligible: z.boolean(),
-    missing_sections: z.array(completenessSectionSchema),
-    truncated_sections: z.array(completenessSectionSchema),
-})
-    .superRefine((value, context) => {
-    const expectedStatus = value.truncated_sections.length > 0
-        ? "truncated"
-        : value.missing_sections.length > 0
-            ? "incomplete"
-            : "complete";
-    if (value.status !== expectedStatus)
-        context.addIssue({
-            code: "custom",
-            path: ["status"],
-            message: "Completeness status does not match section accounting",
+export const browserScenarioCompletenessSchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        status: z.literal("complete"),
+        equality_eligible: z.literal(true),
+        missing_sections: z.tuple([]),
+        truncated_sections: z.tuple([]),
+    }),
+    z.strictObject({
+        status: z.literal("incomplete"),
+        equality_eligible: z.literal(false),
+        missing_sections: z.array(completenessSectionSchema).min(1),
+        truncated_sections: z.tuple([]),
+    }),
+    z.strictObject({
+        status: z.literal("truncated"),
+        equality_eligible: z.literal(false),
+        missing_sections: z.array(completenessSectionSchema),
+        truncated_sections: z.array(completenessSectionSchema).min(1),
+    }),
+]);
+/** Classify canonical browser-scenario completeness from section accounting. */
+export const classifyBrowserScenarioCompleteness = (missing, truncated) => {
+    const missingSections = [...new Set(missing)].sort();
+    const truncatedSections = [...new Set(truncated)].sort();
+    if (truncatedSections.length > 0)
+        return browserScenarioCompletenessSchema.parse({
+            status: "truncated",
+            equality_eligible: false,
+            missing_sections: missingSections,
+            truncated_sections: truncatedSections,
         });
-    if (value.equality_eligible !== (expectedStatus === "complete"))
-        context.addIssue({
-            code: "custom",
-            path: ["equality_eligible"],
-            message: "Missing or truncated evidence is never equality-eligible",
+    if (missingSections.length > 0)
+        return browserScenarioCompletenessSchema.parse({
+            status: "incomplete",
+            equality_eligible: false,
+            missing_sections: missingSections,
+            truncated_sections: [],
         });
-});
-export const browserScenarioStepSchema = z.strictObject({
+    return {
+        status: "complete",
+        equality_eligible: true,
+        missing_sections: [],
+        truncated_sections: [],
+    };
+};
+const browserScenarioStepShape = {
     step_index: z.number().int().min(0),
-    step_id: z.string().min(1).max(64),
-    action: z.string().min(1).max(64),
-    status: z.enum(["completed", "failed", "cancelled"]),
+    step_id: z.string().min(1),
+    action: z.string().min(1),
     elapsed_ms: z.number().int().min(0),
     before_url: sanitizedBrowserUrlSchema,
     after_url: sanitizedBrowserUrlSchema,
-    error: z.string().max(4_096).nullable(),
     event_sequence_start: z.number().int().min(1),
     event_sequence_end: z.number().int().min(0),
     artifacts: browserStepArtifactsSchema,
     completeness: browserScenarioCompletenessSchema,
-});
+};
+export const browserScenarioStepSchema = z.union([
+    z.strictObject({
+        ...browserScenarioStepShape,
+        status: z.literal("completed"),
+        error: z.null(),
+    }),
+    z.strictObject({
+        ...browserScenarioStepShape,
+        status: z.enum(["failed", "cancelled"]),
+        error: z.string(),
+    }),
+]);

package/dist/domain/browserScenarioDiff.js

@@ -1,4 +1,5 @@
 import {} from "./browserScenarioCapture.js";
+import { actionState, artifactEvidenceState, captured, eventEvidenceState, eventsFor, screenshotProjection, } from "./browserScenarioDiffEvidence.js";
 import { browserScenarioDiffSchema, } from "./browserScenarioDiffValues.js";
 import { commitBrowserScenarioNormalization, digestCanonicalJson, digestNormalizedScenarioValue, } from "./browserScenarioNormalization.js";
 export { browserScenarioDiffSchema, compareBrowserScenariosInputSchema, } from "./browserScenarioDiffValues.js";
@@ -11,7 +12,6 @@ export const compareBrowserScenarios = (input) => {
         afterCapture: input.after_scenario,
         alignment,
         rules: normalization.rules,
-        maxChanges: input.max_changes,
     });
     const failures = [...alignment.failures, ...compared.failures];
     const alignmentStatus = failures.length === 0
@@ -29,7 +29,6 @@ export const compareBrowserScenarios = (input) => {
             ? "unknown"
             : "unchanged";
     return browserScenarioDiffSchema.parse({
-        schema_version: 1,
         comparison_kind: "browser_scenario",
         overall_status: overallStatus,
         normalization,
@@ -43,20 +42,12 @@ export const compareBrowserScenarios = (input) => {
         steps: compared.steps,
         artifact_diffs: {
             total: compared.totalArtifactDiffs,
-            retained: compared.totalArtifactDiffs -
-                Math.max(0, compared.totalArtifactDiffs - input.max_changes),
-            omitted: Math.max(0, compared.totalArtifactDiffs - input.max_changes),
         },
         limitations: [
             "Steps align only by exact, unique step_id; missing, duplicate, or action-mismatched steps are reported and prevent an unchanged claim.",
             "Only declared literal normalization rules are applied, in canonical rule_id order, to already-redacted durable capture fields.",
             "Elapsed time and event sequence/index values are excluded as volatile; screenshot bytes are compared by content digest.",
             "A changed status proves an observed normalized difference. Missing or truncated evidence, incompatible capture context, or alignment failure prevents an unchanged claim.",
-            ...(compared.totalArtifactDiffs > input.max_changes
-                ? [
-                    `${String(compared.totalArtifactDiffs - input.max_changes)} artifact difference record(s) were omitted by max_changes.`,
-                ]
-                : []),
         ],
     });
 };
@@ -97,7 +88,6 @@ const alignScenarioSteps = (beforeCapture, afterCapture) => {
     };
 };
 const compareAlignedSteps = (input) => {
-    const remaining = { value: input.maxChanges };
     let totalArtifactDiffs = 0;
     const steps = [];
     const failures = [];
@@ -121,8 +111,6 @@ const compareAlignedSteps = (input) => {
         });
         const reportable = artifacts.flatMap(({ diff }) => diff === null ? [] : [diff]);
         totalArtifactDiffs += reportable.length;
-        const retained = reportable.slice(0, remaining.value);
-        remaining.value -= retained.length;
         const statuses = artifacts.map(({ status }) => status);
         steps.push({
             step_id: stepId,
@@ -135,8 +123,7 @@ const compareAlignedSteps = (input) => {
                 : statuses.includes("unknown")
                     ? "unknown"
                     : "unchanged",
-            artifact_diffs: retained,
-            omitted_artifact_diffs: reportable.length - retained.length,
+            artifact_diffs: reportable,
         });
     }
     return { steps, failures, totalArtifactDiffs };
@@ -278,47 +265,3 @@ const compareCapturedValues = (input) => {
         },
     };
 };
-const artifactEvidenceState = (artifact, state, step) => {
-    if (state.state !== "captured")
-        return state.state;
-    const section = artifact === "action_state" ? "action" : artifact;
-    if (step.completeness.truncated_sections.includes(section))
-        return "truncated";
-    if (step.completeness.missing_sections.includes(section))
-        return "missing";
-    return "captured";
-};
-const eventEvidenceState = (capture, step) => {
-    const sections = [
-        "events",
-        "frames",
-        "workers",
-        "popups",
-        "websockets",
-    ];
-    if (capture.events.dropped > 0 ||
-        sections.some((section) => capture.completeness.truncated_sections.includes(section) ||
-            step.completeness.truncated_sections.includes(section)))
-        return "truncated";
-    if (sections.some((section) => capture.completeness.missing_sections.includes(section) ||
-        step.completeness.missing_sections.includes(section)))
-        return "missing";
-    return "captured";
-};
-const actionState = (step) => ({
-    action: step.action,
-    status: step.status,
-    before_url: step.before_url,
-    after_url: step.after_url,
-    error: step.error,
-});
-const eventsFor = (capture, stepIndex) => capture.events.items.flatMap(({ sequence: _sequence, step_index: eventStepIndex, ...event }) => eventStepIndex === stepIndex ? [event] : []);
-const captured = (value) => ({
-    state: "captured",
-    value,
-});
-const screenshotProjection = (screenshot) => ({
-    sha256: screenshot.sha256,
-    bytes: screenshot.bytes,
-    media_type: screenshot.media_type,
-});

package/dist/domain/browserScenarioDiffEvidence.js

@@ -0,0 +1,51 @@
+const includesCompletenessSection = (completeness, collection, section) => {
+    const sections = completeness[collection];
+    return sections.includes(section);
+};
+/** Project one captured artifact through its step-level completeness ledger. */
+export const artifactEvidenceState = (artifact, state, step) => {
+    if (state.state !== "captured")
+        return state.state;
+    const section = artifact === "action_state" ? "action" : artifact;
+    if (includesCompletenessSection(step.completeness, "truncated_sections", section))
+        return "truncated";
+    return includesCompletenessSection(step.completeness, "missing_sections", section)
+        ? "missing"
+        : "captured";
+};
+const EVENT_SECTIONS = [
+    "events",
+    "frames",
+    "workers",
+    "popups",
+    "websockets",
+];
+/** Project event evidence through capture- and step-level completeness. */
+export const eventEvidenceState = (capture, step) => {
+    const listed = (collection) => EVENT_SECTIONS.some((section) => includesCompletenessSection(capture.completeness, collection, section) ||
+        includesCompletenessSection(step.completeness, collection, section));
+    if (capture.events.dropped > 0 || listed("truncated_sections"))
+        return "truncated";
+    return listed("missing_sections") ? "missing" : "captured";
+};
+/** Select stable action fields for normalized comparison. */
+export const actionState = (step) => ({
+    action: step.action,
+    status: step.status,
+    before_url: step.before_url,
+    after_url: step.after_url,
+    error: step.error,
+});
+/** Select events attributed to one scenario step without sequence metadata. */
+export const eventsFor = (capture, stepIndex) => capture.events.items.flatMap(({ sequence: _sequence, step_index: eventStepIndex, ...event }) => eventStepIndex === stepIndex ? [event] : []);
+/** Wrap one value as captured comparison evidence. */
+export const captured = (value) => ({
+    state: "captured",
+    value,
+});
+/** Retain stable screenshot identity without embedding image bytes. */
+export const screenshotProjection = (screenshot) => ({
+    sha256: screenshot.sha256,
+    bytes: screenshot.bytes,
+    media_type: screenshot.media_type,
+});

package/dist/domain/browserScenarioDiffValues.js

@@ -25,26 +25,22 @@ const normalizationRuleSchema = z.strictObject({
         .string()
         .trim()
         .min(1)
-        .max(64)
         .describe("Stable rule identity; rules execute in rule_id order."),
     artifacts: z
         .array(normalizableArtifactKindSchema)
         .min(1)
-        .max(7)
         .describe("Artifact families whose durable string fields use this rule."),
     match: z
         .string()
         .min(1)
-        .max(4_096)
         .describe("Exact public literal to replace; regular expressions are not used."),
     replacement: z
         .string()
-        .max(4_096)
         .describe("Recorded replacement text used in normalized comparison."),
 });
 const normalizationInputSchema = z
     .strictObject({
-    rules: z.array(normalizationRuleSchema).max(128).default([]),
+    rules: z.array(normalizationRuleSchema).default([]),
 })
     .superRefine((normalization, context) => {
     const ruleIds = new Set();
@@ -70,14 +66,7 @@ export const compareBrowserScenariosInputSchema = z.strictObject({
     after_scenario: browserScenarioCaptureSchema.describe("Later complete capture_browser_scenario result."),
     normalization: normalizationInputSchema
         .default({ rules: [] })
-        .describe("Bounded exact-literal rules committed in the comparison result."),
-    max_changes: z
-        .number()
-        .int()
-        .min(1)
-        .max(20_000)
-        .default(2_000)
-        .describe("Maximum changed or unknown artifact records to retain."),
+        .describe("Exact-literal rules committed in the comparison result."),
 });
 const evidenceStateSchema = z.enum([
     "captured",
@@ -98,7 +87,7 @@ const artifactDiffSchema = z.strictObject({
         .string()
         .regex(/^[a-f0-9]{64}$/u)
         .nullable(),
-    reason: z.string().min(1).max(2_048).nullable(),
+    reason: z.string().min(1).nullable(),
 });
 const alignmentFailureSchema = z.strictObject({
     code: z.enum([
@@ -109,8 +98,8 @@ const alignmentFailureSchema = z.strictObject({
         "action_mismatch",
         "capture_context_mismatch",
     ]),
-    step_id: z.string().min(1).max(64).nullable(),
-    reason: z.string().min(1).max(2_048),
+    step_id: z.string().min(1).nullable(),
+    reason: z.string().min(1),
 });
 const builtInNormalizationSchema = z.enum([
     "ignore_step_elapsed_ms",
@@ -119,39 +108,33 @@ const builtInNormalizationSchema = z.enum([
     "compare_screenshot_content_digest",
     "compare_normalized_text_content",
 ]);
-/** Step alignment, recorded normalization, and bounded artifact differences. */
+/** Step alignment, recorded normalization, and inline artifact differences. */
 export const browserScenarioDiffSchema = z.strictObject({
-    schema_version: z.literal(1),
     comparison_kind: z.literal("browser_scenario"),
     overall_status: z.enum(["changed", "unchanged", "unknown"]),
     normalization: z.strictObject({
         built_in_rules: z.array(builtInNormalizationSchema).length(5),
-        rules: z.array(normalizationRuleSchema).max(128),
+        rules: z.array(normalizationRuleSchema),
         sha256: z.string().regex(/^[a-f0-9]{64}$/u),
     }),
     alignment: z.strictObject({
         status: z.enum(["aligned", "partial", "failed"]),
-        aligned_steps: z.number().int().min(0).max(129),
-        before_only: z.array(z.string().min(1).max(64)).max(129),
-        after_only: z.array(z.string().min(1).max(64)).max(129),
-        failures: z.array(alignmentFailureSchema).max(520),
+        aligned_steps: z.number().int().min(0),
+        before_only: z.array(z.string().min(1)),
+        after_only: z.array(z.string().min(1)),
+        failures: z.array(alignmentFailureSchema),
     }),
-    steps: z
-        .array(z.strictObject({
-        step_id: z.string().min(1).max(64),
-        before_step_index: z.number().int().min(0).max(128),
-        after_step_index: z.number().int().min(0).max(128),
-        before_action: z.string().min(1).max(64),
-        after_action: z.string().min(1).max(64),
+    steps: z.array(z.strictObject({
+        step_id: z.string().min(1),
+        before_step_index: z.number().int().min(0),
+        after_step_index: z.number().int().min(0),
+        before_action: z.string().min(1),
+        after_action: z.string().min(1),
         status: z.enum(["changed", "unchanged", "unknown"]),
-        artifact_diffs: z.array(artifactDiffSchema).max(8),
-        omitted_artifact_diffs: z.number().int().min(0).max(8),
-    }))
-        .max(129),
+        artifact_diffs: z.array(artifactDiffSchema),
+    })),
     artifact_diffs: z.strictObject({
-        total: z.number().int().min(0).max(1_032),
-        retained: z.number().int().min(0).max(1_032),
-        omitted: z.number().int().min(0).max(1_032),
+        total: z.number().int().min(0),
     }),
-    limitations: z.array(z.string().min(1).max(2_048)).max(64),
+    limitations: z.array(z.string().min(1)),
 });