@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
299 lines (287 loc) • 11.5 kB
text/typescript
/**
* `application/vnd.amazon.eventstream` decoder.
*
* Framing logic ported from jawcode `packages/ai/src/providers/aws-eventstream.ts`.
* Foundational dependency for AWS-eventstream providers: kiro (CodeWhisperer
* GenerateAssistantResponse) and amazon-bedrock (Converse). Checksums use Bun's
* native CRC32; framing uses Buffer / DataView / TextDecoder.
*
* Wire format (all integers big-endian):
*
* [total length u32]
* [headers length u32]
* [prelude CRC32 u32] <- CRC over the first 8 bytes
* [headers headers_length]
* [payload total_length - headers_length - 16]
* [message CRC32 u32] <- CRC over the entire message minus the trailing 4 bytes
*
* Headers: a sequence of `[name_len u8][name utf8][value_type u8][value …]`.
*/
const PRELUDE_LEN = 8;
const PRELUDE_CRC_LEN = 4;
const MESSAGE_CRC_LEN = 4;
const HEADER_BLOCK_OFFSET = PRELUDE_LEN + PRELUDE_CRC_LEN;
const MIN_MESSAGE_LEN = HEADER_BLOCK_OFFSET + MESSAGE_CRC_LEN;
const MAX_MESSAGE_LEN = 16 * 1024 * 1024;
const MAX_HEADERS_LEN = 128 * 1024;
export interface EventStreamMessage {
/** Header casing is preserved verbatim (e.g. `:event-type`, `:message-type`). */
headers: Record<string, string>;
payload: Uint8Array;
}
/** Unsigned IEEE CRC32 over this byte view; the seed may continue a previous checksum. */
export function crc32(bytes: Uint8Array, seed = 0): number {
return Bun.hash.crc32(bytes, seed >>> 0);
}
/**
* Decode a single, fully buffered eventstream message. Throws if the framing is
* malformed or either CRC mismatches.
*/
export function decodeMessage(frame: Uint8Array): EventStreamMessage {
if (frame.length < MIN_MESSAGE_LEN) throw new Error("eventstream: frame too short");
const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
const total = view.getUint32(0, false);
if (total !== frame.length) throw new Error(`eventstream: framed length ${total} != buffer ${frame.length}`);
if (total > MAX_MESSAGE_LEN) throw new Error(`eventstream: total length ${total} exceeds maximum`);
const headersLen = view.getUint32(4, false);
const preludeCrc = view.getUint32(8, false);
const computedPreludeCrc = crc32(frame.subarray(0, PRELUDE_LEN));
if (computedPreludeCrc !== preludeCrc) throw new Error("eventstream: prelude CRC mismatch");
if (headersLen > MAX_HEADERS_LEN) throw new Error(`eventstream: headers length ${headersLen} exceeds maximum`);
if (headersLen > total - MIN_MESSAGE_LEN) throw new Error("eventstream: headers length exceeds frame payload");
const msgCrc = view.getUint32(total - MESSAGE_CRC_LEN, false);
const computedMsgCrc = crc32(frame.subarray(0, total - MESSAGE_CRC_LEN));
if (computedMsgCrc !== msgCrc) throw new Error("eventstream: message CRC mismatch");
const headersBytes = frame.subarray(HEADER_BLOCK_OFFSET, HEADER_BLOCK_OFFSET + headersLen);
const payload = frame.subarray(HEADER_BLOCK_OFFSET + headersLen, total - MESSAGE_CRC_LEN);
return { headers: parseHeaders(headersBytes), payload };
}
function parseHeaders(buf: Uint8Array): Record<string, string> {
const out: Record<string, string> = {};
const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
const decoder = new TextDecoder();
let p = 0;
const need = (n: number, label: string) => {
if (p + n > buf.length) throw new Error(`eventstream: truncated header ${label}`);
};
while (p < buf.length) {
need(1, "name length");
const nameLen = view.getUint8(p);
p += 1;
need(nameLen, "name");
const name = decoder.decode(buf.subarray(p, p + nameLen));
p += nameLen;
need(1, "type");
const type = view.getUint8(p);
p += 1;
switch (type) {
case 0: // bool true
out[name] = "true";
break;
case 1: // bool false
out[name] = "false";
break;
case 2: // byte
need(1, "byte value");
out[name] = String(view.getInt8(p));
p += 1;
break;
case 3: // short
need(2, "short value");
out[name] = String(view.getInt16(p, false));
p += 2;
break;
case 4: // integer
need(4, "integer value");
out[name] = String(view.getInt32(p, false));
p += 4;
break;
case 5: // long — decimal string to avoid precision loss
need(8, "long value");
out[name] = bigIntFromBytes(buf.subarray(p, p + 8)).toString();
p += 8;
break;
case 6: {
// byte array — base64 for safe transport
need(2, "byte-array length");
const len = view.getUint16(p, false);
p += 2;
need(len, "byte-array value");
out[name] = Buffer.from(buf.buffer, buf.byteOffset + p, len).toString("base64");
p += len;
break;
}
case 7: {
// string
need(2, "string length");
const len = view.getUint16(p, false);
p += 2;
need(len, "string value");
out[name] = decoder.decode(buf.subarray(p, p + len));
p += len;
break;
}
case 8: // timestamp (ms since epoch as i64)
need(8, "timestamp value");
out[name] = new Date(Number(bigIntFromBytes(buf.subarray(p, p + 8)))).toISOString();
p += 8;
break;
case 9: {
// uuid
need(16, "uuid value");
const u = buf.subarray(p, p + 16);
const hex: string[] = [];
for (let i = 0; i < 16; i++) hex.push(u[i].toString(16).padStart(2, "0"));
out[name] =
`${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
p += 16;
break;
}
default:
throw new Error(`eventstream: unknown header value type ${type}`);
}
}
return out;
}
function bigIntFromBytes(b: Uint8Array): bigint {
let v = 0n;
for (let i = 0; i < b.length; i++) v = (v << 8n) | BigInt(b[i]);
// sign-extend (two's complement)
if (b.length === 8 && b[0] & 0x80) v -= 1n << 64n;
return v;
}
function frameLength(bytes: Uint8Array): number {
const total = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(0, false);
if (total < MIN_MESSAGE_LEN) throw new Error(`eventstream: total length ${total} below minimum`);
if (total > MAX_MESSAGE_LEN) throw new Error(`eventstream: total length ${total} exceeds maximum`);
return total;
}
function validatePrelude(bytes: Uint8Array, total: number): void {
const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
const headersLen = view.getUint32(4, false);
if (crc32(bytes.subarray(0, PRELUDE_LEN)) !== view.getUint32(8, false)) {
throw new Error("eventstream: prelude CRC mismatch");
}
if (headersLen > MAX_HEADERS_LEN) throw new Error(`eventstream: headers length ${headersLen} exceeds maximum`);
if (headersLen > total - MIN_MESSAGE_LEN) throw new Error("eventstream: headers length exceeds frame payload");
}
/**
* Async generator that consumes a `ReadableStream<Uint8Array>` (a fetch response
* body) and yields fully-framed messages, handling arbitrary chunk boundaries.
*/
export async function* decodeEventStream(source: ReadableStream<Uint8Array>): AsyncGenerator<EventStreamMessage> {
const reader = source.getReader();
const empty = new Uint8Array(0);
let carry: Uint8Array = empty;
let used = 0;
let total = 0;
const append = (bytes: Uint8Array): void => {
if (bytes.length === 0) return;
const required = used + bytes.length;
if (required > carry.length) {
// The prelude is tiny; grow payload storage only as bytes actually arrive.
const capacity = Math.min(total || HEADER_BLOCK_OFFSET,
Math.max(required, carry.length < HEADER_BLOCK_OFFSET ? HEADER_BLOCK_OFFSET : Math.max(4096, carry.length * 2)));
const grown = new Uint8Array(capacity);
grown.set(carry.subarray(0, used));
carry = grown;
}
carry.set(bytes, used);
used = required;
};
try {
while (true) {
const { value, done } = await reader.read();
let offset = 0;
while (value && offset < value.length) {
if (used === 0 && value.length - offset >= HEADER_BLOCK_OFFSET) {
const remaining = value.subarray(offset);
total = frameLength(remaining);
validatePrelude(remaining, total);
if (remaining.length >= total) {
// Complete frames borrow the source chunk without a working copy.
yield decodeMessage(remaining.subarray(0, total));
offset += total;
total = 0;
continue;
}
append(remaining);
offset = value.length;
continue;
}
if (used < 4) {
const end = Math.min(value.length, offset + 4 - used);
append(value.subarray(offset, end));
offset = end;
if (used < 4) continue;
total = frameLength(carry);
}
if (used < HEADER_BLOCK_OFFSET) {
const end = Math.min(value.length, offset + HEADER_BLOCK_OFFSET - used);
append(value.subarray(offset, end));
offset = end;
if (used < HEADER_BLOCK_OFFSET) continue;
validatePrelude(carry, total);
}
const end = Math.min(value.length, offset + total - used);
append(value.subarray(offset, end));
offset = end;
if (used === total) {
const frame = carry.subarray(0, used);
// A yielded payload owns this allocation; never overwrite it for a later frame.
carry = empty;
used = 0;
total = 0;
yield decodeMessage(frame);
}
}
if (done) break;
}
if (used > 0) throw new Error("eventstream: truncated message at end of stream");
} finally {
// Early termination (consumer break/return, turn abort, or an HTTP/2 mid-body reset) can leave
// an in-flight `reader.read()` pending when this generator's `finally` runs. Releasing the lock
// does NOT settle that orphaned read — Bun then surfaces it as an off-path
// `unhandledRejection: TypeError: null is not an object` that no caller try/catch can intercept.
// Initiate cancellation before releasing; a hung transport cancellation must not block return.
// Observe its rejection without waiting for physical cleanup. On a clean `done`
// finish the read is already settled, so cancel() is a harmless no-op.
try {
void reader.cancel().catch(() => { /* best-effort transport cleanup */ });
} catch {
/* body already errored/closed — nothing to cancel */
}
try {
reader.releaseLock();
} catch {
/* lock already released by cancel() on some runtimes */
}
}
}
/** Build a single eventstream frame (string headers only) — used by tests and fixtures. */
export function encodeMessage(headers: Record<string, string>, payload: Uint8Array): Uint8Array {
const enc = new TextEncoder();
const headerParts: Uint8Array[] = [];
for (const [name, value] of Object.entries(headers)) {
const nameBytes = enc.encode(name);
const valueBytes = enc.encode(value);
const head = new Uint8Array(1 + nameBytes.length + 1 + 2);
const hv = new DataView(head.buffer);
hv.setUint8(0, nameBytes.length);
head.set(nameBytes, 1);
hv.setUint8(1 + nameBytes.length, 7); // string type
hv.setUint16(1 + nameBytes.length + 1, valueBytes.length, false);
headerParts.push(head, valueBytes);
}
const headersBytes = Buffer.concat(headerParts.map(p => Buffer.from(p)));
const total = HEADER_BLOCK_OFFSET + headersBytes.length + payload.length + MESSAGE_CRC_LEN;
const frame = new Uint8Array(total);
const dv = new DataView(frame.buffer);
dv.setUint32(0, total, false);
dv.setUint32(4, headersBytes.length, false);
dv.setUint32(8, crc32(frame.subarray(0, PRELUDE_LEN)), false);
frame.set(headersBytes, HEADER_BLOCK_OFFSET);
frame.set(payload, HEADER_BLOCK_OFFSET + headersBytes.length);
dv.setUint32(total - MESSAGE_CRC_LEN, crc32(frame.subarray(0, total - MESSAGE_CRC_LEN)), false);
return frame;
}