rea-agents 2.1.0 → 2.3.0

package/dist/domain/replayMachineRuntime.js

@@ -0,0 +1,294 @@
+import canonicalize from "canonicalize";
+import { z } from "zod";
+/** One bounded inbound protocol event offered to a replay machine. */
+const replayEventHeadersSchema = z
+    .record(z
+    .string()
+    .min(1)
+    .max(256)
+    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z
+    .string()
+    .max(8_192)
+    .regex(/^[\t\x20-\x7e\x80-\xff]*$/u))
+    .superRefine((headers, context) => {
+    const normalized = Object.keys(headers).map((name) => name.toLowerCase());
+    if (new Set(normalized).size !== normalized.length)
+        context.addIssue({
+            code: "custom",
+            message: "replay event headers must be unique ignoring case",
+            input: headers,
+        });
+});
+const replayEventFields = {
+    at_ms: z.number().int().nonnegative().safe(),
+    path: z.string().startsWith("/").max(8_192),
+    headers: replayEventHeadersSchema,
+    body: z.string().max(1_000_000),
+};
+export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
+    z.strictObject({
+        protocol: z.literal("http"),
+        connection: z.literal("not_applicable"),
+        method: z
+            .string()
+            .min(1)
+            .max(16)
+            .transform((method) => method.toUpperCase()),
+        ...replayEventFields,
+    }),
+    z.strictObject({
+        protocol: z.literal("websocket_connect"),
+        connection: z.enum(["initial", "reconnect"]),
+        method: z.null(),
+        ...replayEventFields,
+    }),
+    z.strictObject({
+        protocol: z.literal("websocket_message"),
+        connection: z.enum(["initial", "reconnect"]),
+        method: z.null(),
+        ...replayEventFields,
+    }),
+]);
+const parseJson = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+};
+const atPath = (value, path) => {
+    let current = value;
+    for (const segment of path) {
+        if (typeof segment === "number") {
+            if (!Array.isArray(current))
+                return undefined;
+            current = current[segment];
+            continue;
+        }
+        if (typeof current !== "object" ||
+            current === null ||
+            !Object.hasOwn(current, segment))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+};
+const actionJsonBody = (transition) => {
+    for (const action of transition.actions)
+        if (action.type === "http_response")
+            return action.body;
+        else if (action.type === "websocket_send")
+            return action.data;
+    return undefined;
+};
+const readValue = (source, event, transition) => {
+    switch (source.source) {
+        case "request_header":
+            return event.headers[source.name.toLowerCase()];
+        case "request_json":
+            return atPath(parseJson(event.body), source.path);
+        case "websocket_json":
+            return atPath(parseJson(event.body), source.path);
+        case "action_json": {
+            const body = actionJsonBody(transition);
+            return body === undefined
+                ? undefined
+                : atPath(parseJson(body), source.path);
+        }
+    }
+};
+const triggerMatches = (transition, event) => {
+    const trigger = transition.trigger;
+    if (trigger.protocol !== event.protocol || trigger.path !== event.path)
+        return false;
+    if ("headers" in trigger &&
+        Object.entries(trigger.headers).some(([name, value]) => event.headers[name.toLowerCase()] !== value))
+        return false;
+    if (trigger.protocol === "http")
+        return (trigger.method === event.method &&
+            (trigger.body === null || trigger.body === event.body));
+    if (trigger.protocol === "websocket_message")
+        return trigger.body === null || trigger.body === event.body;
+    return true;
+};
+const isJsonCompatible = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonCompatible);
+    if (typeof value !== "object")
+        return false;
+    return Object.values(value).every(isJsonCompatible);
+};
+const replayValuesEqual = (left, right) => isJsonCompatible(left) &&
+    isJsonCompatible(right) &&
+    (Object.is(left, right) || canonicalize(left) === canonicalize(right));
+const createTransitionRecord = ({ sequence, atMs, stateBefore, transition, captures, }) => ({
+    sequence,
+    at_ms: atMs,
+    transition_id: transition.id,
+    state_before: stateBefore,
+    state_after: transition.to,
+    sensitive_aliases: captures
+        .filter(({ sensitive }) => sensitive)
+        .map(({ variable }) => variable)
+        .sort(),
+});
+/** Stateful evaluator for one validated replay-machine instance. */
+export class ReplayMachineRuntime {
+    machine;
+    #variables = new Map();
+    #sensitiveValues = new Map();
+    #uses = new Map();
+    #stateVisits = new Map();
+    #timeline = [];
+    #state;
+    #connections = 0;
+    #messages = 0;
+    #bytes = 0;
+    #lastAtMs = 0;
+    #events = 0;
+    constructor(machine) {
+        this.machine = machine;
+        this.#state = machine.initial_state;
+        this.#stateVisits.set(machine.initial_state, 1);
+    }
+    /** Current machine state after all accepted transitions. */
+    get state() {
+        return this.#state;
+    }
+    /** Ordered, secret-free transition records. */
+    get timeline() {
+        return this.#timeline;
+    }
+    /** Current committed use of the machine's declared limits. */
+    get usage() {
+        return {
+            events: this.#events,
+            transitions: this.#timeline.length,
+            connections: this.#connections,
+            messages: this.#messages,
+            bytes: this.#bytes,
+            last_at_ms: this.#lastAtMs,
+        };
+    }
+    /** Replace captured secret values with stable aliases before persistence. */
+    redact(value) {
+        let redacted = value;
+        const secrets = [...this.#sensitiveValues]
+            .flatMap(([variable, values]) => [...values].map((secret) => ({ variable, secret })))
+            .sort((left, right) => right.secret.length - left.secret.length ||
+            left.variable.localeCompare(right.variable));
+        for (const { variable, secret } of secrets)
+            redacted = redacted.replaceAll(secret, `<secret:${variable}>`);
+        return redacted;
+    }
+    /** Replace a field containing captured secrets with one stable alias only. */
+    redactField(value) {
+        const alias = [...this.#sensitiveValues]
+            .filter(([, values]) => [...values].some((secret) => value.includes(secret)))
+            .map(([variable]) => variable)
+            .sort()[0];
+        return alias === undefined ? value : `<secret:${alias}>`;
+    }
+    /** Evaluate and, when admitted, commit one protocol event. */
+    dispatch(event) {
+        const normalizedEvent = {
+            ...event,
+            headers: Object.fromEntries(Object.entries(event.headers).map(([name, value]) => [
+                name.toLowerCase(),
+                value,
+            ])),
+        };
+        if (!this.#admitEvent(normalizedEvent))
+            return this.#refusal("limit_exhausted");
+        const matching = this.machine.transitions
+            .map((transition, declarationOrder) => ({
+            transition,
+            declarationOrder,
+        }))
+            .filter(({ transition }) => triggerMatches(transition, normalizedEvent));
+        const eligible = matching
+            .filter(({ transition }) => transition.from === this.#state)
+            .sort((left, right) => left.transition.priority - right.transition.priority ||
+            left.declarationOrder - right.declarationOrder);
+        if (eligible.length === 0)
+            return this.#refusal(matching.length === 0
+                ? "unmatched"
+                : normalizedEvent.protocol === "websocket_connect" &&
+                    normalizedEvent.connection === "reconnect"
+                    ? "unexpected_reconnect"
+                    : "invalid_state");
+        const guarded = eligible.filter(({ transition }) => transition.guards.every((guard) => this.#variables.has(guard.variable) &&
+            replayValuesEqual(this.#variables.get(guard.variable), readValue(guard.value, normalizedEvent, transition))));
+        if (guarded.length === 0)
+            return this.#refusal("guard_failed");
+        if (this.#timeline.length >= this.machine.max_transitions)
+            return this.#refusal("transition_exhausted");
+        const usable = guarded.find(({ transition }) => (this.#uses.get(transition.id) ?? 0) < transition.max_uses);
+        if (usable === undefined)
+            return this.#refusal("transition_exhausted");
+        const transition = usable.transition;
+        const used = this.#uses.get(transition.id) ?? 0;
+        const nextState = this.machine.states.find(({ name }) => name === transition.to);
+        const nextVisits = (this.#stateVisits.get(transition.to) ?? 0) + 1;
+        if (nextState === undefined || nextVisits > nextState.max_visits)
+            return this.#refusal("limit_exhausted");
+        const captures = transition.captures.map((capture) => ({
+            ...capture,
+            captured: readValue(capture.value, normalizedEvent, transition),
+        }));
+        if (captures.some(({ captured, sensitive }) => !isJsonCompatible(captured) ||
+            (sensitive && typeof captured !== "string")))
+            return this.#refusal("invalid_capture");
+        for (const capture of captures) {
+            this.#variables.set(capture.variable, capture.captured);
+            if (capture.sensitive && typeof capture.captured === "string") {
+                const values = this.#sensitiveValues.get(capture.variable) ?? new Set();
+                if (capture.captured.length > 0)
+                    values.add(capture.captured);
+                this.#sensitiveValues.set(capture.variable, values);
+            }
+        }
+        const record = createTransitionRecord({
+            sequence: this.#timeline.length,
+            atMs: normalizedEvent.recorded_at_ms ?? normalizedEvent.at_ms,
+            stateBefore: this.#state,
+            transition,
+            captures,
+        });
+        this.#uses.set(transition.id, used + 1);
+        this.#stateVisits.set(transition.to, nextVisits);
+        this.#state = transition.to;
+        this.#timeline.push(record);
+        return {
+            outcome: "matched",
+            actions: transition.actions,
+            transition: record,
+        };
+    }
+    #admitEvent(event) {
+        const connections = this.#connections + (event.protocol === "websocket_connect" ? 1 : 0);
+        const messages = this.#messages + (event.protocol === "websocket_message" ? 1 : 0);
+        const bytes = this.#bytes + Buffer.byteLength(event.body);
+        if (!Number.isSafeInteger(event.at_ms) ||
+            event.at_ms < this.#lastAtMs ||
+            event.at_ms > this.machine.limits.duration_ms ||
+            connections > this.machine.limits.connections ||
+            messages > this.machine.limits.messages ||
+            bytes > this.machine.limits.bytes)
+            return false;
+        this.#connections = connections;
+        this.#messages = messages;
+        this.#bytes = bytes;
+        this.#lastAtMs = event.at_ms;
+        this.#events += 1;
+        return true;
+    }
+    #refusal(outcome) {
+        return { outcome, actions: [], transition: null };
+    }
+}

package/dist/domain/runtimeIdentification.js

@@ -0,0 +1,210 @@
+import { createHash } from "node:crypto";
+import canonicalize from "canonicalize";
+import { z } from "zod";
+import { parseArtifactInventoryEvidence } from "./artifactInventoryEvidence.js";
+import { evidenceSchema } from "./evidence.js";
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const runtimeFamilySchema = z.enum([
+    "android",
+    "apple",
+    "javascript",
+    "jvm",
+    "native",
+    "webassembly",
+]);
+const observationSchema = z.strictObject({
+    path: z.string().min(1).max(4_096),
+    artifact_id: z.string().regex(/^art_[a-f0-9]{64}$/u),
+    sha256: digestSchema,
+    format: z.string().min(1).max(100),
+});
+/** Authenticated artifact inventory pages to classify by runtime family. */
+const runtimeIdentificationInputSchema = z.strictObject({
+    inventory_evidence: z.array(evidenceSchema).min(1).max(100),
+    limits: z
+        .strictObject({
+        max_observations: z.number().int().min(1).max(10_000).default(1_000),
+    })
+        .default({ max_observations: 1_000 }),
+});
+/** Provider-neutral runtime identification with explicit tooling availability. */
+export const runtimeIdentificationResultSchema = z.strictObject({
+    schema_version: z.literal(1),
+    identification_id: z.string().regex(/^rid_[a-f0-9]{64}$/u),
+    root_sha256: digestSchema,
+    root_format: z.string().min(1).max(100),
+    source_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
+    runtimes: z.array(z.strictObject({
+        family: runtimeFamilySchema,
+        inspection: z.enum([
+            "available",
+            "provider-missing",
+            "provider-selection-required",
+        ]),
+        provider_id: z.string().min(1).max(200).nullable(),
+        reason: z.string().min(1).max(1_000).nullable(),
+        observations: z.array(observationSchema),
+        omitted_observations: z.number().int().min(0),
+    })),
+    coverage: z.strictObject({
+        status: z.enum(["complete-within-inventory", "partial", "truncated"]),
+        inventory_complete: z.boolean(),
+        omitted_observations: z.number().int().min(0),
+    }),
+    limitations: z.array(z.string().min(1).max(4_096)).max(100),
+});
+const PROVIDERS = {
+    android: {
+        inspection: "available",
+        id: "rea-android-application",
+        reason: null,
+    },
+    apple: { inspection: "available", id: "rea-apple-application", reason: null },
+    javascript: {
+        inspection: "available",
+        id: "rea-javascript-application",
+        reason: null,
+    },
+    jvm: {
+        inspection: "provider-missing",
+        id: null,
+        reason: "Install or configure a JVM bytecode-analysis provider.",
+    },
+    native: {
+        inspection: "provider-selection-required",
+        id: null,
+        reason: "Select an available native deep-analysis provider for this target and host.",
+    },
+    webassembly: {
+        inspection: "provider-missing",
+        id: null,
+        reason: "Install or configure a WebAssembly semantic-analysis provider.",
+    },
+};
+/** Identify runtime families without executing or semantically decoding target bytes. */
+export const identifyRuntimes = (input) => {
+    const parsed = runtimeIdentificationInputSchema.parse(input);
+    const { evidence, inventory } = parseArtifactInventoryEvidence(parsed.inventory_evidence);
+    const nodes = new Map(inventory.nodes.map((node) => [node.artifact_id, node]));
+    const grouped = new Map();
+    const add = (family, observation) => {
+        const observations = grouped.get(family) ?? [];
+        observations.push(observation);
+        grouped.set(family, observations);
+    };
+    for (const occurrence of inventory.occurrences) {
+        if (occurrence.artifact_id === null)
+            continue;
+        const node = nodes.get(occurrence.artifact_id);
+        if (node === undefined)
+            throw new TypeError("Runtime observation has no artifact node");
+        const observation = {
+            path: occurrence.logical_path,
+            artifact_id: node.artifact_id,
+            sha256: node.sha256,
+            format: node.format,
+        };
+        for (const family of familiesFor(node.format, occurrence.logical_path))
+            add(family, observation);
+    }
+    const rootObservation = inventory.nodes.find(({ sha256 }) => sha256 === inventory.manifest.root_sha256);
+    if (rootObservation !== undefined)
+        for (const family of familiesFor(inventory.manifest.root_format, "."))
+            add(family, {
+                path: ".",
+                artifact_id: rootObservation.artifact_id,
+                sha256: rootObservation.sha256,
+                format: rootObservation.format,
+            });
+    let remaining = parsed.limits.max_observations;
+    let omitted = 0;
+    const runtimes = [...grouped.entries()]
+        .sort(([left], [right]) => compare(left, right))
+        .map(([family, values]) => {
+        const unique = deduplicate(values);
+        const observations = unique.slice(0, remaining);
+        remaining -= observations.length;
+        const omittedObservations = unique.length - observations.length;
+        omitted += omittedObservations;
+        const provider = providerFor(family, inventory.manifest.root_format);
+        return {
+            family,
+            inspection: provider.inspection,
+            provider_id: provider.id,
+            reason: provider.reason,
+            observations,
+            omitted_observations: omittedObservations,
+        };
+    });
+    const limitations = [
+        ...(!inventory.complete
+            ? [
+                "Source inventory pages are incomplete; absent runtimes remain unknown.",
+            ]
+            : []),
+        ...(omitted > 0
+            ? [`${String(omitted)} runtime observations were omitted by the limit.`]
+            : []),
+        "Runtime families are identified from exact artifact formats and paths; semantic claims require the named provider.",
+    ];
+    const withoutId = {
+        schema_version: 1,
+        root_sha256: inventory.manifest.root_sha256,
+        root_format: inventory.manifest.root_format,
+        source_evidence_ids: evidence
+            .map(({ evidence_id: id }) => id)
+            .sort(compare),
+        runtimes,
+        coverage: {
+            status: omitted > 0
+                ? "truncated"
+                : inventory.complete
+                    ? "complete-within-inventory"
+                    : "partial",
+            inventory_complete: inventory.complete,
+            omitted_observations: omitted,
+        },
+        limitations,
+    };
+    return runtimeIdentificationResultSchema.parse({
+        ...withoutId,
+        identification_id: `rid_${digest(withoutId)}`,
+    });
+};
+const providerFor = (family, rootFormat) => family === "android" && rootFormat !== "apk"
+    ? {
+        inspection: "provider-selection-required",
+        id: null,
+        reason: "Extract or select an APK root before using the Android application provider.",
+    }
+    : PROVIDERS[family];
+const familiesFor = (format, path) => {
+    const families = new Set();
+    if (format === "apk" ||
+        format === "dex" ||
+        /(?:^|\/)[^/]+\.dex$/iu.test(path) ||
+        /(?:^|\/)AndroidManifest\.xml$/u.test(path))
+        families.add("android");
+    if (format === "ipa")
+        families.add("apple");
+    if (format === "javascript-bundle")
+        families.add("javascript");
+    if (format === "jvm-class" || /(?:^|\/)[^/]+\.class$/iu.test(path))
+        families.add("jvm");
+    if (["elf", "mach-o", "mach-o-universal", "pe"].includes(format))
+        families.add("native");
+    if (format === "webassembly" || /(?:^|\/)[^/]+\.wasm$/iu.test(path))
+        families.add("webassembly");
+    return [...families];
+};
+const deduplicate = (values) => [
+    ...new Map(values.map((value) => [`${value.path}\0${value.artifact_id}`, value])).values(),
+].sort((left, right) => compare(left.path, right.path));
+const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+const digest = (value) => {
+    const encoded = canonicalize(value);
+    if (encoded === undefined)
+        throw new TypeError("Runtime identification is not canonical JSON");
+    return createHash("sha256").update(encoded).digest("hex");
+};

package/dist/domain/staticRuntimeCorrelation.js

@@ -140,7 +140,7 @@ const EXPECTED = {
         "REA function comparison",
     ],
     compare_process_captures: [
-        "rea.process-comparison/v3",
+        ["rea.process-comparison/v3", "rea.process-comparison/v4"],
         "rea-process",
         "REA deterministic process harness",
     ],
@@ -302,7 +302,9 @@ const parseRuntime = (input) => {
 const assertComparisonIdentity = (evidence) => {
     const expected = EXPECTED[evidence.operation];
     if (expected === undefined ||
-        evidence.predicate_type !== expected[0] ||
+        !(Array.isArray(expected[0])
+            ? expected[0].includes(evidence.predicate_type)
+            : evidence.predicate_type === expected[0]) ||
         evidence.provider.id !== expected[1] ||
         evidence.provider.name !== expected[2] ||
         evidence.provider.version !==

package/dist/evaluation/CodexAgentEval.js

@@ -0,0 +1,156 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const record = (value) => isRecord(value) ? value : undefined;
+const textValue = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+const numberValue = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+const canonicalValue = (value) => {
+    if (Array.isArray(value))
+        return value.map(canonicalValue);
+    const object = record(value);
+    if (object === undefined)
+        return value;
+    return Object.fromEntries(Object.entries(object)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, child]) => [key, canonicalValue(child)]));
+};
+const evidenceIdsFrom = (value) => {
+    const encoded = JSON.stringify(value);
+    if (encoded === undefined)
+        return [];
+    return [...new Set(encoded.match(/ev_[a-f0-9]{64}/gu) ?? [])];
+};
+const toolResultFailed = (item) => {
+    if (item.status === "failed" ||
+        (item.error !== undefined && item.error !== null))
+        return true;
+    const result = record(item.result ?? item.output);
+    const structured = record(result?.structured_content ?? result?.structuredContent);
+    return result?.isError === true || structured?.error !== undefined;
+};
+const toolResultErrorCode = (item) => {
+    const result = record(item.result ?? item.output);
+    const structured = record(result?.structured_content ?? result?.structuredContent);
+    const error = record(structured?.error ?? result?.error ?? item.error);
+    return textValue(error?.code) ?? null;
+};
+const callFromItem = (value) => {
+    const item = record(value);
+    if (item?.type !== "mcp_tool_call")
+        return undefined;
+    const tool = textValue(item.tool) ?? textValue(item.name);
+    if (tool === undefined)
+        return undefined;
+    return {
+        id: textValue(item.id) ?? null,
+        server: textValue(item.server) ?? textValue(item.server_name) ?? null,
+        tool,
+        arguments: item.arguments ?? item.input ?? {},
+        evidenceIds: evidenceIdsFrom(item.result ?? item.output),
+        error: toolResultFailed(item),
+        errorCode: toolResultErrorCode(item),
+    };
+};
+const agentTextFromItem = (value) => {
+    const item = record(value);
+    if (item?.type !== "agent_message")
+        return undefined;
+    const direct = textValue(item.text) ?? textValue(item.message);
+    if (direct !== undefined)
+        return direct;
+    if (!Array.isArray(item.content))
+        return undefined;
+    const parts = item.content.flatMap((part) => {
+        const object = record(part);
+        const text = object === undefined ? undefined : textValue(object.text);
+        return text === undefined ? [] : [text];
+    });
+    return parts.length === 0 ? undefined : parts.join("\n");
+};
+const consumeEvent = (state, value) => {
+    const event = record(value);
+    if (event === undefined)
+        return;
+    const completedItem = event.type === "item.completed" ? event.item : undefined;
+    const call = callFromItem(completedItem) ??
+        (event.type === "mcp_tool_call" ? callFromItem(event) : undefined);
+    if (call !== undefined) {
+        const identity = call.id ??
+            `${call.server ?? ""}:${call.tool}:${JSON.stringify(canonicalValue(call.arguments))}`;
+        if (!state.seenCallIds.has(identity)) {
+            state.seenCallIds.add(identity);
+            state.calls.push(call);
+        }
+    }
+    const message = agentTextFromItem(completedItem);
+    if (message !== undefined)
+        state.finalMessages.push(message);
+    if (event.type !== "turn.completed")
+        return;
+    const usage = record(event.usage);
+    state.inputTokens = Math.max(state.inputTokens, numberValue(usage?.input_tokens));
+    state.cachedInputTokens = Math.max(state.cachedInputTokens, numberValue(usage?.cached_input_tokens));
+    state.outputTokens = Math.max(state.outputTokens, numberValue(usage?.output_tokens));
+};
+/** Score agent routing, repetition, model usage, and epistemic completion. */
+export const evaluateCodexEvents = (events, expectedFirstTool, options = {}) => {
+    const state = {
+        calls: [],
+        seenCallIds: new Set(),
+        finalMessages: [],
+        inputTokens: 0,
+        cachedInputTokens: 0,
+        outputTokens: 0,
+    };
+    for (const event of events)
+        consumeEvent(state, event);
+    const reaCalls = state.calls.filter(({ server }) => server === null || server.toLowerCase() === "rea");
+    const signatures = new Map();
+    for (const call of reaCalls) {
+        const signature = `${call.tool}:${JSON.stringify(canonicalValue(call.arguments))}`;
+        signatures.set(signature, (signatures.get(signature) ?? 0) + 1);
+    }
+    const repeatedCallCount = [...signatures.values()].reduce((total, count) => total + Math.max(0, count - 1), 0);
+    const inputValidationFailureCount = reaCalls.filter(({ errorCode }) => errorCode === "invalid_request").length;
+    const requiredToolSubsequenceMet = containsOrderedSubsequence(reaCalls.filter(({ error }) => !error).map(({ tool }) => tool), options.requiredToolSubsequence ?? []);
+    const finalMessage = state.finalMessages.at(-1) ?? "";
+    const evidenceIds = [
+        ...new Set(reaCalls.flatMap(({ evidenceIds: ids }) => ids)),
+    ];
+    const finalCitesEvidence = evidenceIds.some((evidenceId) => finalMessage.includes(evidenceId));
+    const normalizedFinalMessage = finalMessage.toLocaleLowerCase("en-US");
+    const contentCriteriaMet = (options.requiredAnswerTermGroups ?? []).every((terms) => terms.some((term) => normalizedFinalMessage.includes(term.toLocaleLowerCase("en-US"))));
+    const authorityHonesty = /\b(evidence|observed|inferred|unknown|unavailable|limitation|authority|not configured|could not|requires approval)\b/iu.test(finalMessage);
+    return {
+        naturalUse: reaCalls.length > 0,
+        correctFirstTool: reaCalls[0]?.tool === expectedFirstTool,
+        firstTool: reaCalls[0]?.tool ?? null,
+        reaCalls,
+        repeatedCallCount,
+        inputValidationFailureCount,
+        requiredToolSubsequenceMet,
+        inputTokens: state.inputTokens,
+        cachedInputTokens: state.cachedInputTokens,
+        outputTokens: state.outputTokens,
+        finalMessage,
+        evidenceIds,
+        finalCitesEvidence,
+        contentCriteriaMet,
+        completionQuality: finalMessage.trim().length >= 80 &&
+            authorityHonesty &&
+            contentCriteriaMet &&
+            requiredToolSubsequenceMet &&
+            (options.forbidInputValidationFailures !== true ||
+                inputValidationFailureCount === 0) &&
+            (options.requireEvidence !== true || finalCitesEvidence),
+        authorityHonesty,
+    };
+};
+const containsOrderedSubsequence = (values, required) => {
+    let index = 0;
+    for (const value of values) {
+        if (value === required[index])
+            index += 1;
+        if (index === required.length)
+            return true;
+    }
+    return required.length === 0;
+};

package/dist/generatedPackageMetadata.js

@@ -1,9 +1,9 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "2.1.0",
+    version: "2.3.0", // x-release-please-version
     serverSdkVersion: "2.0.0-beta.4",
     clientSdkVersion: "2.0.0-beta.4",
     coreSdkVersion: "2.0.0-beta.4",
-    skillVersion: "22",
+    skillVersion: "23",
 };