@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
62 lines (59 loc) • 2.61 kB
text/typescript
/**
* The source envelope of one inference request (PF-06).
*
* SERVER SIDE, not a leaf: it charges the request's translator budget. The envelope keeps the
* body the ingress parsed, by reference, for the lifetime of the request and nothing longer —
* it is a local of the ingress, never stored on a shared or long-lived object. Features are
* scanned once, on first use, so a caller that never asks pays nothing. `freshBody()` hands out
* an independent copy, charged under `request_copies`, so a consumer that rewrites its body in
* place can never leak that rewrite into another consumer's input.
*/
import { jsonUtf8Bytes } from "../lib/json-byte-size";
import type { TranslatorBudget } from "../lib/translator-budget";
import type { Protocol } from "./contract";
import { featuresFromBody, type ProtocolFeature } from "./features";
export interface ProtocolEnvelope {
readonly inbound: Protocol;
/** The request features, scanned from the source body on the first call and cached. */
features(): ReadonlySet<ProtocolFeature>;
/** The source body itself, uncharged, for checks that only read it; a rewrite takes `freshBody()`. */
readBody(): Readonly<Record<string, unknown>>;
/** A structured clone of the source body, charged to the translator budget. */
freshBody(): Record<string, unknown>;
/** Hand back the charge of a `freshBody()` copy no longer needed; later calls are no-ops. */
releaseBody(copy: Record<string, unknown>): void;
}
export function createProtocolEnvelope(input: {
inbound: Protocol;
body: Record<string, unknown>;
translatorBudget: TranslatorBudget;
}): ProtocolEnvelope {
const { inbound, body, translatorBudget } = input;
let features: ReadonlySet<ProtocolFeature> | undefined;
// The copy's own size may change once its holder rewrites it, so the charge is remembered.
const charged = new WeakMap<object, number>();
return {
inbound,
features() {
features ??= featuresFromBody(inbound, body);
return features;
},
readBody() {
return body;
},
freshBody() {
// Charged before the copy exists, so an over-budget request fails without allocating it.
const bytes = jsonUtf8Bytes(body);
translatorBudget.chargeRetained(bytes, { kind: "request_copies" });
const copy = structuredClone(body);
charged.set(copy, bytes);
return copy;
},
releaseBody(copy) {
const bytes = charged.get(copy);
if (bytes === undefined) return;
charged.delete(copy);
translatorBudget.releaseRetained(bytes, { kind: "request_copies" });
},
};
}