@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

package/runtime/node_modules/@metro-labs/daemon/src/gateway/codex-translate.ts

@@ -0,0 +1,209 @@
+import { createHash } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
+import { inlineImage, partText, resultImages, resultParts, resultText, TOOL_ERROR, type InlineImage } from './text.js';
+import { stringOf } from '@metro-labs/http/api-http';
+
+const SIGNATURE_PREFIX = 'metro-codex:';
+const DEFAULT_EFFORT = 'medium';
+const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
+const EFFORT_ALIAS: Record<string, string> = { max: 'xhigh' };
+const NAME_MAX = 64;
+const NAME_RE = /^[a-zA-Z0-9_-]+$/;
+const HASH_LEN = 8;
+
+type Item = Record<string, unknown>;
+
+export interface TranslateOptions {
+  promptCacheKey: string;
+  names?: ToolNames;
+}
+
+export interface ResponsesRequest {
+  model: string;
+  instructions?: string;
+  input: Item[];
+  tools: Item[];
+  tool_choice: unknown;
+  parallel_tool_calls: boolean;
+  reasoning: { effort: string; summary: string };
+  store: false;
+  stream: true;
+  include: string[];
+  prompt_cache_key: string;
+}
+
+
+export function codexToolName(name: string): string {
+  if (name.length <= NAME_MAX && NAME_RE.test(name)) return name;
+  const clean = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const hash = createHash('sha256').update(name).digest('hex').slice(0, HASH_LEN);
+  return `${clean.slice(0, NAME_MAX - HASH_LEN - 1)}_${hash}`;
+}
+
+export class ToolNames {
+  private readonly original = new Map<string, string>();
+
+  alias(name: string): string {
+    const alias = codexToolName(name);
+    if (alias !== name) this.original.set(alias, name);
+    return alias;
+  }
+
+  restore(alias: string): string {
+    return this.original.get(alias) ?? alias;
+  }
+}
+
+function blocksText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter(isRecord)
+    .filter((block) => block.type === 'text')
+    .map((block) => stringOf(block.text))
+    .join('\n');
+}
+
+export function systemText(system: unknown): string {
+  return blocksText(system).trim();
+}
+
+export function encodeSignature(item: Item): string {
+  return `${SIGNATURE_PREFIX}${Buffer.from(JSON.stringify(item)).toString('base64url')}`;
+}
+
+export function decodeSignature(signature: unknown): Item | null {
+  if (typeof signature !== 'string' || !signature.startsWith(SIGNATURE_PREFIX)) return null;
+  try {
+    const parsed: unknown = JSON.parse(Buffer.from(signature.slice(SIGNATURE_PREFIX.length), 'base64url').toString('utf8'));
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+const imagePart = (image: InlineImage): Item => ({ type: 'input_image', image_url: `data:${image.mediaType};base64,${image.data}` });
+
+function userPart(block: Item): Item | null {
+  if (block.type === 'text') return { type: 'input_text', text: stringOf(block.text) };
+  const image = inlineImage(block);
+  return image === null ? null : imagePart(image);
+}
+
+function outputPart(part: Item): Item | null {
+  const image = inlineImage(part);
+  if (image !== null) return imagePart(image);
+  const text = partText(part);
+  return text === '' ? null : { type: 'input_text', text };
+}
+
+function toolOutput(block: Item): string | Item[] {
+  if (resultImages(block).length === 0) return resultText(block);
+  const parts = resultParts(block).map(outputPart).filter((part): part is Item => part !== null);
+  return block.is_error === true ? [{ type: 'input_text', text: TOOL_ERROR }, ...parts] : parts;
+}
+
+function userItems(content: unknown): Item[] {
+  if (typeof content === 'string') return [{ type: 'message', role: 'user', content: [{ type: 'input_text', text: content }] }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  let parts: Item[] = [];
+  const flush = (): void => {
+    if (parts.length > 0) out.push({ type: 'message', role: 'user', content: parts });
+    parts = [];
+  };
+  for (const block of content.filter(isRecord)) {
+    if (block.type === 'tool_result') {
+      flush();
+      out.push({ type: 'function_call_output', call_id: stringOf(block.tool_use_id), output: toolOutput(block) });
+      continue;
+    }
+    const part = userPart(block);
+    if (part !== null) parts.push(part);
+  }
+  flush();
+  return out;
+}
+
+function assistantItems(content: unknown, names: ToolNames): Item[] {
+  if (typeof content === 'string') return [{ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: content }] }];
+  if (!Array.isArray(content)) return [];
+  const out: Item[] = [];
+  for (const block of content.filter(isRecord)) {
+    if (block.type === 'text') out.push({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: stringOf(block.text) }] });
+    else if (block.type === 'tool_use')
+      out.push({ type: 'function_call', call_id: stringOf(block.id), name: names.alias(stringOf(block.name)), arguments: JSON.stringify(block.input ?? {}) });
+    else if (block.type === 'thinking') {
+      const reasoning = decodeSignature(block.signature);
+      if (reasoning !== null) out.push({ type: 'reasoning', ...reasoning, summary: [] });
+    }
+  }
+  return out;
+}
+
+export function inputItems(messages: unknown, names = new ToolNames()): Item[] {
+  const out: Item[] = [];
+  if (!Array.isArray(messages)) return out;
+  for (const message of messages.filter(isRecord)) {
+    if (message.role === 'assistant') out.push(...assistantItems(message.content, names));
+    else out.push(...userItems(message.content));
+  }
+  return out;
+}
+
+export function toolItems(tools: unknown, names = new ToolNames()): Item[] {
+  if (!Array.isArray(tools)) return [];
+  return tools
+    .filter(isRecord)
+    .filter((tool) => typeof tool.name === 'string' && isRecord(tool.input_schema))
+    .map((tool) => ({
+      type: 'function',
+      name: names.alias(stringOf(tool.name)),
+      description: stringOf(tool.description),
+      parameters: tool.input_schema,
+      strict: false,
+    }));
+}
+
+export function toolChoiceOf(choice: unknown, names = new ToolNames()): unknown {
+  if (!isRecord(choice)) return 'auto';
+  if (choice.type === 'any') return 'required';
+  if (choice.type === 'none') return 'none';
+  if (choice.type === 'tool' && typeof choice.name === 'string') return { type: 'function', name: names.alias(choice.name) };
+  return 'auto';
+}
+
+function configuredEffort(body: Item): string | null {
+  const config = isRecord(body.output_config) ? body.output_config : {};
+  const effort = typeof config.effort === 'string' ? (EFFORT_ALIAS[config.effort] ?? config.effort) : '';
+  return EFFORTS.has(effort) ? effort : null;
+}
+
+export function effortOf(body: Item): string {
+  const configured = configuredEffort(body);
+  if (configured !== null) return configured;
+  const thinking = isRecord(body.thinking) ? body.thinking : {};
+  if (thinking.type === 'disabled') return 'low';
+  const budget = typeof thinking.budget_tokens === 'number' ? thinking.budget_tokens : 0;
+  if (budget > 0 && budget <= 4_000) return 'low';
+  if (budget > 16_000) return 'high';
+  return DEFAULT_EFFORT;
+}
+
+export function toResponsesRequest(body: Item, model: string, opts: TranslateOptions): ResponsesRequest {
+  const system = systemText(body.system);
+  const names = opts.names ?? new ToolNames();
+  return {
+    model,
+    ...(system === '' ? {} : { instructions: system }),
+    input: inputItems(body.messages, names),
+    tools: toolItems(body.tools, names),
+    tool_choice: toolChoiceOf(body.tool_choice, names),
+    parallel_tool_calls: true,
+    reasoning: { effort: effortOf(body), summary: 'auto' },
+    store: false,
+    stream: true,
+    include: ['reasoning.encrypted_content'],
+    prompt_cache_key: opts.promptCacheKey,
+  };
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/codex-version.ts

@@ -0,0 +1,44 @@
+import { errMsg, log } from '@metro-labs/core/log';
+
+const BUILT_IN = '0.157.1';
+const REGISTRY = 'https://registry.npmjs.org/@openai/codex/latest';
+const OVERRIDE_RE = /^\d+\.\d+\.\d+(?:-[A-Za-z0-9.]+)?$/;
+const STABLE_RE = /^\d+\.\d+\.\d+$/;
+const FRESH_MS = 6 * 3_600_000;
+const FETCH_MS = 5_000;
+
+let learned: { version: string; at: number } | null = null;
+
+const parts = (version: string): number[] => version.split('.').map(Number);
+
+function newer(a: string, b: string): boolean {
+  const [x, y] = [parts(a), parts(b)];
+  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
+  return false;
+}
+
+export function codexVersion(): string {
+  const wanted = process.env.METRO_CODEX_VERSION?.trim() ?? '';
+  if (wanted !== '' && OVERRIDE_RE.test(wanted)) return wanted;
+  if (wanted !== '') log.warn({ value: wanted }, 'gateway: METRO_CODEX_VERSION is not a version like 0.157.1; using the known one');
+  return learned !== null && newer(learned.version, BUILT_IN) ? learned.version : BUILT_IN;
+}
+
+async function latestOnNpm(): Promise<string> {
+  const res = await fetch(process.env.METRO_CODEX_REGISTRY ?? REGISTRY, { signal: AbortSignal.timeout(FETCH_MS) });
+  const body: unknown = await res.json();
+  const version = typeof body === 'object' && body !== null ? (body as { version?: unknown }).version : undefined;
+  if (!res.ok || typeof version !== 'string' || !STABLE_RE.test(version)) throw new Error(`npm answered ${String(res.status)} without a stable version`);
+  return version;
+}
+
+export async function learnCodexVersion(now = Date.now()): Promise<string> {
+  if (learned !== null && now - learned.at < FRESH_MS) return codexVersion();
+  try {
+    learned = { version: await latestOnNpm(), at: now };
+  } catch (err) {
+    log.warn({ err: errMsg(err) }, 'gateway: the latest Codex version could not be read from npm; using the known one');
+    learned = { version: learned?.version ?? BUILT_IN, at: now };
+  }
+  return codexVersion();
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/codex.ts

@@ -0,0 +1,143 @@
+import { randomUUID } from 'node:crypto';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { arch, platform, release } from 'node:os';
+import { isRecord } from '@metro-labs/core/is-record';
+import { stringOf } from '@metro-labs/http/api-http';
+import { OPENAI_API, CODEX_SIGN_IN, refreshTokens, tokensStale, type CodexTokens } from './codex-auth.js';
+import { refreshCodeTokens } from './codex-device.js';
+import { codexVersion, learnCodexVersion } from './codex-version.js';
+import { CodexEventTranslator, withUsageLink } from './codex-stream.js';
+import { ToolNames, toResponsesRequest } from './codex-translate.js';
+import { GatewayError, providerStatus, sendError, upstreamMessage, type Watch } from './forward.js';
+import { parseEvent, SseParser, type SseEvent } from './frames.js';
+import type { Connection } from './model-config.js';
+import { listCache } from './model-lists.js';
+import { answerWhole, currentOf, errorKind, reach, refreshed, relayTranslated, sessionHeader, type TokenSource, type TokenState } from './subscription.js';
+import { noteUsageHeaders } from './usage.js';
+
+const CODEX_BACKEND = 'https://chatgpt.com/backend-api/codex';
+const INVALID = [400, 404, 422];
+
+export interface CodexDeps {
+  base?: string;
+  issuer?: string;
+  fetchImpl?: typeof fetch;
+  save: (id: string, tokens: CodexTokens) => void;
+}
+
+export type CodexState = TokenState<CodexTokens>;
+
+export const sharedCodexState: CodexState = new Map();
+
+const codexLists = listCache<string>('codex');
+
+const sourceOf = (deps: CodexDeps): TokenSource<CodexTokens> => ({
+  label: 'Codex',
+  stale: (tokens) => tokensStale(tokens),
+  refresh: (tokens) => (tokens.method === 'code' ? refreshCodeTokens(tokens, deps.issuer, deps.fetchImpl) : refreshTokens(tokens, deps.issuer, deps.fetchImpl)),
+  save: deps.save,
+});
+
+const OS_NAMES: Record<string, string> = { darwin: 'Mac OS', linux: 'Linux', win32: 'Windows' };
+
+export const userAgent = (): string => `codex_cli_rs/${codexVersion()} (${OS_NAMES[platform()] ?? platform()} ${release()}; ${arch()}) metro`;
+
+const baseFor = (tokens: CodexTokens, deps: Pick<CodexDeps, 'base'>): string => deps.base ?? (tokens.method === 'code' ? CODEX_BACKEND : OPENAI_API);
+
+function headersFor(tokens: CodexTokens, accept: string, sessionId: string): Record<string, string> {
+  const plain = { authorization: `Bearer ${tokens.accessToken}`, 'content-type': 'application/json', accept };
+  if (tokens.method === 'chatgpt') return plain;
+  return {
+    ...plain,
+    'chatgpt-account-id': tokens.accountId,
+    originator: 'codex_cli_rs',
+    'user-agent': userAgent(),
+    'openai-beta': 'responses=experimental',
+    'session-id': sessionId,
+  };
+}
+
+export const currentTokens = (conn: Connection, deps: CodexDeps, state: CodexState): Promise<CodexTokens> =>
+  currentOf(state, conn.id, conn.codex, sourceOf(deps), CODEX_SIGN_IN);
+
+interface Call {
+  body: Record<string, unknown>;
+  model: string;
+  sessionId: string;
+  watch: Watch;
+  deps: CodexDeps;
+  names: ToolNames;
+}
+
+function send(call: Call, tokens: CodexTokens): Promise<Response> {
+  const request = toResponsesRequest(call.body, call.model, { promptCacheKey: call.sessionId, names: call.names });
+  return (call.deps.fetchImpl ?? fetch)(`${baseFor(tokens, call.deps)}/responses`, {
+    method: 'POST',
+    headers: headersFor(tokens, 'text/event-stream', call.sessionId),
+    body: JSON.stringify(request),
+    signal: call.watch.signal,
+    redirect: 'manual',
+  });
+}
+
+function refusalOf(text: string, status: number): string {
+  let code = '';
+  try {
+    const parsed: unknown = JSON.parse(text);
+    code = isRecord(parsed) && isRecord(parsed.error) ? stringOf(parsed.error.code) : '';
+  } catch {
+    code = '';
+  }
+  return withUsageLink(code, upstreamMessage(text, `OpenAI answered ${String(status)}`));
+}
+
+export async function codexMessages(
+  req: IncomingMessage,
+  res: ServerResponse,
+  body: Record<string, unknown>,
+  model: string,
+  conn: Connection,
+  deps: CodexDeps,
+  state: CodexState,
+  watch: Watch,
+): Promise<void> {
+  const call: Call = { body, model, sessionId: sessionHeader(req) || randomUUID(), watch, deps, names: new ToolNames() };
+  const upstream = await reach(
+    () => currentTokens(conn, deps, state),
+    (tokens) => refreshed(state, conn.id, tokens, sourceOf(deps)),
+    (tokens) => send(call, tokens),
+  );
+  noteUsageHeaders('codex', conn.id, upstream.headers);
+  if (!upstream.ok) {
+    const text = await upstream.text();
+    sendError(res, providerStatus(upstream.status), errorKind(upstream.status, INVALID), refusalOf(text, upstream.status));
+    return;
+  }
+  const translator = new CodexEventTranslator(model, (name) => call.names.restore(name));
+  const onEvent = (raw: SseEvent): string => {
+    const parsed = parseEvent(raw);
+    return parsed === null ? '' : translator.push(parsed.event, parsed.data);
+  };
+  if (body.stream === true) {
+    await relayTranslated(upstream, res, watch, conn.id, translator, onEvent);
+    return;
+  }
+  const frames = new SseParser().push(await upstream.text()).map(onEvent).join('');
+  answerWhole(res, frames + translator.close(), conn.id);
+}
+
+export async function codexModels(tokens: CodexTokens, deps: Omit<CodexDeps, 'save'>): Promise<string[]> {
+  const base = baseFor(tokens, deps);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (tokens.method === 'chatgpt') return codexLists.get(`${base}:${tokens.clientId}`, () => listCodex(tokens, `${base}/models`, fetchImpl));
+  const version = await learnCodexVersion();
+  return codexLists.get(`${base}:${tokens.accountId}:${version}`, () => listCodex(tokens, `${base}/models?client_version=${version}`, fetchImpl));
+}
+
+async function listCodex(tokens: CodexTokens, url: string, fetchImpl: typeof fetch): Promise<string[]> {
+  const res = await fetchImpl(url, { headers: headersFor(tokens, 'application/json', randomUUID()), redirect: 'manual' });
+  if (!res.ok) throw new GatewayError(res.status, errorKind(res.status, INVALID), `OpenAI would not list the models of this ChatGPT plan (${String(res.status)})`);
+  const body: unknown = await res.json();
+  const models: unknown[] = isRecord(body) && Array.isArray(body.models) ? body.models : [];
+  return models.filter(isRecord).flatMap((m) => ((m.visibility ?? 'list') === 'list' && stringOf(m.slug) !== '' ? [stringOf(m.slug)] : []));
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/effort.ts

@@ -0,0 +1,103 @@
+import type { IncomingMessage } from 'node:http';
+import { isRecord } from '@metro-labs/core/is-record';
+
+const MAIN_EFFORT = 'low';
+const SUBAGENT_EFFORT = 'max';
+export const BINDING_BETA = 'thinking-binding-controls-2026-08-01';
+
+const SUBAGENT_HEADER = 'x-claude-code-agent-id';
+const SUBAGENT_MARK = 'cc_is_subagent=true';
+const ABOVE_HIGH = new Set(['xhigh', 'max']);
+
+export type RequestKind = 'main' | 'subagent' | 'other';
+
+type Body = Record<string, unknown>;
+
+const record = (value: unknown): Body => (isRecord(value) ? value : {});
+
+const effortOf = (body: Body): string => {
+  const effort = record(body.output_config).effort;
+  return typeof effort === 'string' ? effort : '';
+};
+
+function header(req: IncomingMessage, name: string): string {
+  const raw = req.headers[name];
+  return (Array.isArray(raw) ? raw[0] : raw)?.trim() ?? '';
+}
+
+function systemMarksSubagent(body: Body): boolean {
+  const system = body.system;
+  if (!Array.isArray(system)) return false;
+  return system.some((block) => isRecord(block) && typeof block.text === 'string' && block.text.includes(SUBAGENT_MARK));
+}
+
+const chore = (body: Body): boolean => record(body.output_config).format !== undefined || record(body.thinking).type === 'disabled';
+
+export function requestKind(req: IncomingMessage, body: Body): RequestKind {
+  if (header(req, SUBAGENT_HEADER) !== '' || systemMarksSubagent(body)) return 'subagent';
+  return chore(body) ? 'other' : 'main';
+}
+
+const messagesOf = (body: Body): unknown[] => (Array.isArray(body.messages) ? body.messages : []);
+
+const askedEfforts = (body: Body): string[] => [body, ...messagesOf(body).map(record)].map(effortOf).filter((effort) => effort !== '');
+
+export function plannedEffort(req: IncomingMessage, body: Body): string | null {
+  const asked = askedEfforts(body);
+  if (asked.length === 0) return null;
+  const kind = requestKind(req, body);
+  if (kind === 'other') return null;
+  const wanted = kind === 'subagent' ? SUBAGENT_EFFORT : MAIN_EFFORT;
+  return asked.every((effort) => effort === wanted) ? null : wanted;
+}
+
+const withOwnEffort = (item: Body, effort: string): Body => (effortOf(item) === '' ? item : { ...item, output_config: { ...record(item.output_config), effort } });
+
+export function withEffort(body: Body, effort: string): Body {
+  const top = withOwnEffort(body, effort);
+  if (!Array.isArray(body.messages)) return top;
+  return { ...top, messages: body.messages.map((message: unknown) => (isRecord(message) ? withOwnEffort(message, effort) : message)) };
+}
+
+export function withoutEffort(body: Body): Body {
+  const config = Object.fromEntries(Object.entries(record(body.output_config)).filter(([key]) => key !== 'effort'));
+  if (Object.keys(config).length > 0) return { ...body, output_config: config };
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'output_config'));
+}
+
+export function effortToApply(body: Body): string | null {
+  if (chore(body)) return null;
+  const effort = effortOf(body);
+  return effort === '' ? null : effort;
+}
+
+export const cappedEffort = (effort: string): string => (ABOVE_HIGH.has(effort) ? 'high' : effort);
+
+const THINKING_ALWAYS_ON = /claude-(fable|mythos)-5|claude-opus-5-5/;
+const REFUSES_THINKING_OFF = '"thinking.type.disabled" is not supported';
+const thinkingAlwaysOn = new Set<string>();
+
+export const thinkingOff = (body: Body): boolean => record(body.thinking).type === 'disabled';
+
+const alwaysThinks = (model: string): boolean => THINKING_ALWAYS_ON.test(model) || thinkingAlwaysOn.has(model);
+
+export function withThinkingFor(body: Body, model: string): Body {
+  if (!alwaysThinks(model) || !thinkingOff(body)) return body;
+  return Object.fromEntries(Object.entries(body).filter(([key]) => key !== 'thinking'));
+}
+
+export function learnAlwaysThinks(model: string, refusal: string): boolean {
+  if (!refusal.includes(REFUSES_THINKING_OFF)) return false;
+  thinkingAlwaysOn.add(model);
+  return true;
+}
+
+export function forgetLearnedThinking(): void {
+  thinkingAlwaysOn.clear();
+}
+
+export function withBlockBinding(body: Body): Body {
+  const thinking = body.thinking;
+  if (!isRecord(thinking) || thinking.block_binding !== undefined) return body;
+  return { ...body, thinking: { ...thinking, block_binding: { prefix_mismatch_behavior: 'drop_block' } } };
+}

package/runtime/node_modules/@metro-labs/daemon/src/gateway/eventstream.ts

@@ -0,0 +1,123 @@
+export interface EventStreamMessage {
+  headers: Record<string, string>;
+  payload: Buffer;
+}
+
+const PRELUDE_BYTES = 12;
+const CRC_BYTES = 4;
+
+const HEADER_TRUE = 0;
+const HEADER_FALSE = 1;
+const HEADER_BYTE = 2;
+const HEADER_SHORT = 3;
+const HEADER_INT = 4;
+const HEADER_LONG = 5;
+const HEADER_BYTES = 6;
+const HEADER_STRING = 7;
+const HEADER_TIMESTAMP = 8;
+const HEADER_UUID = 9;
+
+const FIXED_WIDTH: Record<number, number> = {
+  [HEADER_TRUE]: 0,
+  [HEADER_FALSE]: 0,
+  [HEADER_BYTE]: 1,
+  [HEADER_SHORT]: 2,
+  [HEADER_INT]: 4,
+  [HEADER_LONG]: 8,
+  [HEADER_TIMESTAMP]: 8,
+  [HEADER_UUID]: 16,
+};
+
+function readHeaderValue(buf: Buffer, at: number, type: number): { value: string; next: number } {
+  if (type === HEADER_BYTES || type === HEADER_STRING) {
+    const len = buf.readUInt16BE(at);
+    const raw = buf.subarray(at + 2, at + 2 + len);
+    const value = type === HEADER_STRING ? raw.toString('utf8') : raw.toString('base64');
+    return { value, next: at + 2 + len };
+  }
+  const width = FIXED_WIDTH[type];
+  if (width === undefined) throw new Error(`eventstream: unknown header type ${String(type)}`);
+  if (type === HEADER_TRUE) return { value: 'true', next: at };
+  if (type === HEADER_FALSE) return { value: 'false', next: at };
+  return { value: buf.subarray(at, at + width).toString('hex'), next: at + width };
+}
+
+function readHeaders(buf: Buffer): Record<string, string> {
+  const out: Record<string, string> = {};
+  let at = 0;
+  while (at < buf.length) {
+    const nameLen = buf.readUInt8(at);
+    const name = buf.subarray(at + 1, at + 1 + nameLen).toString('utf8');
+    const type = buf.readUInt8(at + 1 + nameLen);
+    const parsed = readHeaderValue(buf, at + 2 + nameLen, type);
+    out[name] = parsed.value;
+    at = parsed.next;
+  }
+  return out;
+}
+
+function decodeFrame(buf: Buffer, offset: number): { message: EventStreamMessage; end: number } | null {
+  if (buf.length - offset < PRELUDE_BYTES) return null;
+  const total = buf.readUInt32BE(offset);
+  const headersLen = buf.readUInt32BE(offset + 4);
+  if (total < PRELUDE_BYTES + CRC_BYTES || headersLen > total) throw new Error('eventstream: malformed frame prelude');
+  if (buf.length - offset < total) return null;
+  const headersStart = offset + PRELUDE_BYTES;
+  const payloadStart = headersStart + headersLen;
+  const payloadEnd = offset + total - CRC_BYTES;
+  return {
+    message: {
+      headers: readHeaders(buf.subarray(headersStart, payloadStart)),
+      payload: Buffer.from(buf.subarray(payloadStart, payloadEnd)),
+    },
+    end: offset + total,
+  };
+}
+
+export class EventStreamDecoder {
+  private pending: Buffer = Buffer.alloc(0);
+
+  push(chunk: Buffer): EventStreamMessage[] {
+    this.pending = this.pending.length === 0 ? chunk : Buffer.concat([this.pending, chunk]);
+    const out: EventStreamMessage[] = [];
+    let offset = 0;
+    for (;;) {
+      const frame = decodeFrame(this.pending, offset);
+      if (frame === null) break;
+      out.push(frame.message);
+      offset = frame.end;
+    }
+    this.pending = this.pending.subarray(offset);
+    return out;
+  }
+}
+
+function encodeHeader(name: string, value: string): Buffer {
+  const nameBuf = Buffer.from(name, 'utf8');
+  const valueBuf = Buffer.from(value, 'utf8');
+  const out = Buffer.alloc(1 + nameBuf.length + 1 + 2 + valueBuf.length);
+  let at = 0;
+  out.writeUInt8(nameBuf.length, at);
+  at += 1;
+  nameBuf.copy(out, at);
+  at += nameBuf.length;
+  out.writeUInt8(HEADER_STRING, at);
+  at += 1;
+  out.writeUInt16BE(valueBuf.length, at);
+  at += 2;
+  valueBuf.copy(out, at);
+  return out;
+}
+
+export function encodeFrame(headers: Record<string, string>, payload: Buffer): Buffer {
+  const headerBuf = Buffer.concat(Object.entries(headers).map(([name, value]) => encodeHeader(name, value)));
+  const total = PRELUDE_BYTES + headerBuf.length + payload.length + CRC_BYTES;
+  const out = Buffer.alloc(total);
+  out.writeUInt32BE(total, 0);
+  out.writeUInt32BE(headerBuf.length, 4);
+  out.writeUInt32BE(0, 8);
+  headerBuf.copy(out, PRELUDE_BYTES);
+  payload.copy(out, PRELUDE_BYTES + headerBuf.length);
+  out.writeUInt32BE(0, total - CRC_BYTES);
+  return out;
+}