import { compareToolCallShape, stableHash } from "./parity-shared.js";

// Qa Lab plugin module implements harness parity behavior.

import { createHash } from "node:crypto";

import type {

RuntimeId,

RuntimeParityCell,

firstDriftTurn?: number;

};

function sha256(value: string) {

return createHash("sha256").update(value).digest("hex");

}

function countComparableTranscriptRecords(transcriptBytes: string) {

let count = 0;

for (const line of transcriptBytes.split(/\r?\n/u)) {

return count;

}

function normalizeForStableHash(value: unknown): unknown {

if (Array.isArray(value)) {

return value.map((entry) => normalizeForStableHash(entry));

}

if (value && typeof value === "object") {

const record = value as Record<string, unknown>;

return Object.fromEntries(

Object.keys(record)

.toSorted((left, right) => left.localeCompare(right))

.map((key) => [key, normalizeForStableHash(record[key])]),

);

}

return value;

}

function stableHash(value: unknown) {

return sha256(JSON.stringify(normalizeForStableHash(value)) ?? "null");

}

function readPositiveNumber(value: unknown) {

return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;

}

return text.replace(/\s+/gu, " ").trim();

}

function compareToolCallShape(left: RuntimeParityToolCall[], right: RuntimeParityToolCall[]) {

if (left.length !== right.length) {

return `tool call count differs (${left.length} vs ${right.length})`;

}

for (let index = 0; index < left.length; index += 1) {

const leftCall = left[index];

const rightCall = right[index];

if (!leftCall || !rightCall) {

return `tool call row ${index + 1} missing`;

}

if (leftCall.tool !== rightCall.tool || leftCall.argsHash !== rightCall.argsHash) {

return `tool call ${index + 1} differs (${leftCall.tool}/${leftCall.argsHash} vs ${rightCall.tool}/${rightCall.argsHash})`;

}

}

return undefined;

}

function compareToolResultShape(left: RuntimeParityToolCall[], right: RuntimeParityToolCall[]) {

const total = Math.min(left.length, right.length);

for (let index = 0; index < total; index += 1) {

// Qa Lab plugin module implements shared parity comparison helpers.

import { createHash } from "node:crypto";

type ParityToolCallShape = {

argsHash: string;

tool: string;

};

function sha256(value: string) {

return createHash("sha256").update(value).digest("hex");

}

function normalizeForStableHash(value: unknown): unknown {

if (Array.isArray(value)) {

return value.map((entry) => normalizeForStableHash(entry));

}

if (value && typeof value === "object") {

const record = value as Record<string, unknown>;

return Object.fromEntries(

Object.keys(record)

.toSorted((left, right) => left.localeCompare(right))

.map((key) => [key, normalizeForStableHash(record[key])]),

);

}

return value;

}

export function stableHash(value: unknown) {

return sha256(JSON.stringify(normalizeForStableHash(value)) ?? "null");

}

export function compareToolCallShape(

left: readonly ParityToolCallShape[],

right: readonly ParityToolCallShape[],

): string | undefined {

if (left.length !== right.length) {

return `tool call count differs (${left.length} vs ${right.length})`;

}

for (let index = 0; index < left.length; index += 1) {

const leftCall = left[index];

const rightCall = right[index];

if (!leftCall || !rightCall) {

return `tool call row ${index + 1} missing`;

}

if (leftCall.tool !== rightCall.tool || leftCall.argsHash !== rightCall.argsHash) {

return `tool call ${index + 1} differs (${leftCall.tool}/${leftCall.argsHash} vs ${rightCall.tool}/${rightCall.argsHash})`;

}

}

return undefined;

}

// Qa Lab plugin module implements runtime parity behavior.

import { createHash } from "node:crypto";

import fs from "node:fs/promises";

import path from "node:path";

import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";

scanGatewayLogSentinels,

type GatewayLogSentinelFinding,

} from "./gateway-log-sentinel.js";

import { compareToolCallShape, stableHash } from "./parity-shared.js";

export type RuntimeId = "openclaw" | "codex";

return text.replace(/\s+/gu, " ").trim();

}

function sha256(value: string) {

return createHash("sha256").update(value).digest("hex");

}

function normalizeForStableHash(value: unknown): unknown {

if (Array.isArray(value)) {

return value.map((entry) => normalizeForStableHash(entry));

}

if (value && typeof value === "object") {

const record = value as Record<string, unknown>;

return Object.fromEntries(

Object.keys(record)

.toSorted((left, right) => left.localeCompare(right))

.map((key) => [key, normalizeForStableHash(record[key])]),

);

}

return value;

}

function stableHash(value: unknown) {

return sha256(JSON.stringify(normalizeForStableHash(value)) ?? "null");

}

function readUsageTotals(raw: unknown): RuntimeParityUsage {

const usage = isMessageRecord(raw) ? raw : {};

const inputTokens =

return totals;

}

function compareToolCallShape(

left: RuntimeParityToolCall[],

right: RuntimeParityToolCall[],

): string | undefined {

if (left.length !== right.length) {

return `tool call count differs (${left.length} vs ${right.length})`;

}

for (let index = 0; index < left.length; index += 1) {

const leftCall = left[index];

const rightCall = right[index];

if (!leftCall || !rightCall) {

return `tool call row ${index + 1} missing`;

}

if (leftCall.tool !== rightCall.tool || leftCall.argsHash !== rightCall.argsHash) {

return `tool call ${index + 1} differs (${leftCall.tool}/${leftCall.argsHash} vs ${rightCall.tool}/${rightCall.argsHash})`;

}

}

return undefined;

}

function compareToolResultShape(

left: RuntimeParityToolCall[],

right: RuntimeParityToolCall[],