Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import crypto from "node:crypto";
/**
* Streaming JSON hash — computes `sha256hex(JSON.stringify(value))` WITHOUT
* materializing the JSON string (#7847 OOM class). Several hot-path call sites
* stringify a multi-megabyte request body just to hash it (compression memo
* keys, cache keys). On a ~5 MiB agent body (with base64 screenshots) that
* allocates a full ~5 MiB string, read once for a hash, then discarded.
*
* `jsonSha256()` walks the value and feeds the same bytes `JSON.stringify`
* would emit directly into a `crypto.createHash("sha256")` stream, so peak
* allocation stays bounded to a small rolling buffer.
*
* Semantics mirror `JSON.stringify` exactly:
* - key order = `Object.keys()` order (insertion order)
* - `undefined`/function/symbol object values drop the whole entry
* - `undefined`/function/symbol array items render as `null`
* - non-finite numbers render as `null`
* - `BigInt` throws (matches JSON.stringify)
* - Date / toJSON / non-plain containers fall back to `JSON.stringify` for
* that subtree only (kept rare so big arrays stay on the fast path).
*
* Deterministic across calls: identical logical bodies always produce the
* identical digest, so callers can replace `sha256hex(JSON.stringify(body))`
* with `jsonSha256(body)` without changing cache/memo semantics.
*/
export function jsonSha256(value: unknown): string {
const hash = crypto.createHash("sha256");
writeValue(hash, value, new Set<object>());
return hash.digest("hex");
}
function isOmitted(value: unknown): boolean {
return value === undefined || typeof value === "function" || typeof value === "symbol";
}
function isPlainContainer(value: object): boolean {
if (Array.isArray(value)) return true;
const proto = Object.getPrototypeOf(value);
return proto === Object.prototype || proto === null;
}
function writeValue(
hash: ReturnType<typeof crypto.createHash>,
value: unknown,
seen: Set<object>
): void {
if (writePrimitive(hash, value)) return;
const obj = value as object;
// Date, Map, boxed primitives, class instances with toJSON — fall back to
// JSON.stringify for THIS SUBTREE only, keeping multi-MB arrays on the
// streaming path. JSON.stringify(Date) emits a quoted ISO string, so push
// exactly the string form JSON.stringify would have produced.
if (writeToJSONFallback(hash, obj)) return;
if (Array.isArray(obj)) {
if (seen.has(obj)) {
throw new TypeError("Converting circular structure to JSON");
}
seen.add(obj);
try {
writeArray(hash, obj, seen);
} finally {
seen.delete(obj);
}
} else {
writePlainObject(hash, obj, seen);
}
}
/**
* toJSON / non-plain-container fallback: serializes the subtree with
* JSON.stringify, exactly as JSON.stringify would have (undefined → the bare
* token, e.g. an object-valued key being dropped later is not possible here
* — writeValue callers already filter omissions). Returns true when handled.
*/
function writeToJSONFallback(
hash: ReturnType<typeof crypto.createHash>,
obj: object
): boolean {
const hasToJSON = typeof (obj as { toJSON?: unknown }).toJSON === "function";
if (hasToJSON || !isPlainContainer(obj)) {
const encoded = JSON.stringify(obj);
hash.update(encoded === undefined ? "undefined" : encoded);
return true;
}
return false;
}
/** Writes JSON primitives and omissions. Returns true when `value` is fully handled. */
function writePrimitive(hash: ReturnType<typeof crypto.createHash>, value: unknown): boolean {
if (value === null) {
hash.update("null");
return true;
}
const type = typeof value;
if (type === "string") {
writeEncodedString(hash, value as string);
return true;
}
if (type === "boolean") {
hash.update(value ? "true" : "false");
return true;
}
if (type === "number") {
// Non-finite numbers serialize as null (matches JSON.stringify).
hash.update(Number.isFinite(value as number) ? String(value) : "null");
return true;
}
if (type === "bigint") {
// Matches JSON.stringify, which throws rather than guessing an encoding.
throw new TypeError("Do not know how to serialize a BigInt");
}
if (isOmitted(value) || type !== "object") {
return true;
}
return false;
}
function writeArray(
hash: ReturnType<typeof crypto.createHash>,
obj: unknown[],
seen: Set<object>
): void {
hash.update("[");
for (let i = 0; i < obj.length; i++) {
if (i > 0) hash.update(",");
const item = obj[i];
if (isOmitted(item)) {
hash.update("null"); // array items render as null
} else {
writeValue(hash, item, seen);
}
}
hash.update("]");
}
function writePlainObject(
hash: ReturnType<typeof crypto.createHash>,
obj: object,
seen: Set<object>
): void {
if (seen.has(obj)) {
throw new TypeError("Converting circular structure to JSON");
}
seen.add(obj);
try {
hash.update("{");
let first = true;
for (const key of Object.keys(obj)) {
const item = (obj as Record<string, unknown>)[key];
if (isOmitted(item)) continue; // entry disappears entirely
if (!first) hash.update(",");
first = false;
writeEncodedString(hash, key);
hash.update(":");
writeValue(hash, item, seen);
}
hash.update("}");
} finally {
seen.delete(obj);
}
}
// Static escapes for fast paths: quote, backslash, and the short control
// escapes JSON.stringify emits. Lookup avoids the escape ladder entirely.
const SINGLE_ESCAPES = new Map<number, string>([
[0x22, '\\"'],
[0x5c, "\\\\"],
[0x08, "\\b"],
[0x09, "\\t"],
[0x0a, "\\n"],
[0x0c, "\\f"],
[0x0d, "\\r"],
]);
/** Writes one (possibly surrogate-paired) code unit's escaped form. */
function appendEscapedChar(out: string[], value: string, i: number, code: number): number {
const single = SINGLE_ESCAPES.get(code);
if (single !== undefined) {
out.push(single);
return i;
}
if (code < 0x20) {
out.push("\\u" + code.toString(16).padStart(4, "0"));
return i;
}
if (code >= 0xd800 && code <= 0xdfff) {
const next = i + 1 < value.length ? value.charCodeAt(i + 1) : NaN;
const isHigh = code >= 0xd800 && code <= 0xdbff;
if (isHigh && next >= 0xdc00 && next <= 0xdfff) {
out.push(value[i] + value[i + 1]);
return i + 1;
}
out.push("\\u" + code.toString(16).padStart(4, "0"));
return i;
}
out.push(value[i]);
return i;
}
/** Writes a JSON-escaped, double-quoted string, flushing in ~8 KiB chunks. */
function writeEncodedString(hash: ReturnType<typeof crypto.createHash>, value: string): void {
const out: string[] = [];
let buffered = 0;
let i = 0;
out.push('"');
while (i < value.length) {
const next = appendEscapedChar(out, value, i, value.charCodeAt(i));
buffered += next - i + 1;
i = next + 1;
if (buffered > 8192) {
hash.update(out.join(""));
out.length = 0;
buffered = 0;
}
}
out.push('"');
hash.update(out.join(""));
}