@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
336 lines (297 loc) • 12.3 kB
text/typescript
/**
* Client-facing repair for GitHub Copilot's `vscode-chat` Responses stream.
*
* Copilot can rotate opaque response/item ids between lifecycle events, expose
* provider-private reasoning ciphertext, and attach per-delta obfuscation
* padding while the authoritative complete tool input arrives on `.done`.
* Stock Responses clients cannot reconcile that dialect. This stateful block
* rewrite emits one coherent Responses SSE stream while the inspection branch
* keeps the raw upstream snapshot for provider replay.
*/
import {
TranslatorBudgetExceededError,
type TranslatorBudget,
} from "../lib/translator-budget";
import {
replaceSseDataPayload,
splitSseBlock,
sseLineEnding as blockNewline,
sseDataPayload,
type SseBlockRewrite,
} from "./sse-payload-rewrite";
const MAX_TRACKED_ITEMS = 256;
const MAX_TRACKED_DEFERRED_CALLS = 256;
const RETAINED_STATE_LIMIT_BYTES = 256 * 1024;
type JsonRecord = Record<string, unknown>;
type TrackedItem = {
id: string;
type?: string;
encryptedReasoning: boolean;
};
type DeferredCallKind = "function" | "custom";
function isRecord(value: unknown): value is JsonRecord {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function outputIndexOf(value: unknown): number | undefined {
return typeof value === "number" && Number.isInteger(value) && value >= 0
? value
: undefined;
}
function byteLength(value: unknown): number {
return Buffer.byteLength(JSON.stringify(value), "utf8");
}
/** Keep a named SSE block's `event:` field aligned with its JSON `type`. */
function withEventName(block: string, eventName: string): string {
const { newline, lines } = splitSseBlock(block);
let replaced = false;
const rewritten = lines.flatMap((line) => {
if (!line.startsWith("event:")) return [line];
if (replaced) return [];
replaced = true;
return [`event: ${eventName}`];
});
if (!replaced) {
const dataIndex = rewritten.findIndex(line => line.startsWith("data:"));
rewritten.splice(dataIndex >= 0 ? dataIndex : 0, 0, `event: ${eventName}`);
}
return rewritten.join(newline);
}
function rewriteJsonBlock(block: string, event: JsonRecord): string {
const type = typeof event.type === "string" ? event.type : "message";
return withEventName(replaceSseDataPayload(block, JSON.stringify(event)), type);
}
function syntheticJsonBlock(template: string, event: JsonRecord): string {
const newline = blockNewline(template);
const type = typeof event.type === "string" ? event.type : "message";
return `event: ${type}${newline}data: ${JSON.stringify(event)}`;
}
function callKindForDelta(type: unknown): DeferredCallKind | undefined {
if (type === "response.function_call_arguments.delta") return "function";
if (type === "response.custom_tool_call_input.delta") return "custom";
return undefined;
}
function callKindForDone(type: unknown): DeferredCallKind | undefined {
if (type === "response.function_call_arguments.done") return "function";
if (type === "response.custom_tool_call_input.done") return "custom";
return undefined;
}
function callKey(kind: DeferredCallKind, outputIndex: number): string {
return `${kind}:${outputIndex}`;
}
function deltaTypeFor(kind: DeferredCallKind): string {
return kind === "function"
? "response.function_call_arguments.delta"
: "response.custom_tool_call_input.delta";
}
function completeValueFor(kind: DeferredCallKind, event: JsonRecord): string {
const value = kind === "function" ? event.arguments : event.input;
return typeof value === "string" ? value : "";
}
/**
* Create one provider-scoped block rewrite per upstream response.
*
* Retained ids and pending-call markers are charged to the request translator
* budget and hard-capped. `dispose` releases them on terminal, EOF, cancel, or
* relay failure through the shared block-rewrite lifecycle.
*/
export function createGithubCopilotResponsesBlockRewrite(
budget?: TranslatorBudget,
): SseBlockRewrite {
const items = new Map<number, TrackedItem>();
const deferredCalls = new Map<string, number>();
let responseId: string | undefined;
let itemStateBytes = 0;
let callStateBytes = 0;
let nextSequenceNumber = 0;
let itemTrackingTainted = false;
let disposed = false;
const ensureStateLimit = (nextBytes: number): void => {
if (itemStateBytes + callStateBytes + nextBytes > RETAINED_STATE_LIMIT_BYTES) {
throw new TranslatorBudgetExceededError("item_ids", RETAINED_STATE_LIMIT_BYTES);
}
};
const chargeItemState = (bytes: number): void => {
ensureStateLimit(bytes);
budget?.chargeRetained(bytes, { kind: "item_ids" });
itemStateBytes += bytes;
};
const chargeCallState = (bytes: number): void => {
ensureStateLimit(bytes);
budget?.chargeRetained(bytes, { kind: "retained_collectors" });
callStateBytes += bytes;
};
const releaseDeferredCall = (key: string): boolean => {
const bytes = deferredCalls.get(key);
if (bytes === undefined) return false;
deferredCalls.delete(key);
callStateBytes -= bytes;
budget?.releaseRetained(bytes, { kind: "retained_collectors" });
return true;
};
const rememberResponseId = (candidate: string): string => {
if (responseId !== undefined) return responseId;
const bytes = byteLength(candidate);
chargeItemState(bytes);
responseId = candidate;
return candidate;
};
const rememberItem = (
outputIndex: number,
candidateId: string,
itemType?: string,
encryptedReasoning = false,
): TrackedItem => {
const existing = items.get(outputIndex);
if (existing) {
if (existing.type === undefined && itemType !== undefined) {
const extra = byteLength(itemType);
chargeItemState(extra);
existing.type = itemType;
}
existing.encryptedReasoning ||= encryptedReasoning;
return existing;
}
if (itemTrackingTainted || items.size >= MAX_TRACKED_ITEMS) {
// Keep relaying client-visible events after the count cap, but stop
// retaining new output-index mappings. The current event still receives
// the provider id, while earlier retained mappings remain available for
// stable ids. Byte-budget failures stay hard failures.
itemTrackingTainted = true;
return { id: candidateId, type: itemType, encryptedReasoning };
}
chargeItemState(byteLength([outputIndex, candidateId, itemType ?? null]));
const tracked = { id: candidateId, type: itemType, encryptedReasoning };
items.set(outputIndex, tracked);
return tracked;
};
const rememberDeferredCall = (key: string): void => {
if (deferredCalls.has(key)) return;
if (deferredCalls.size >= MAX_TRACKED_DEFERRED_CALLS) {
throw new TranslatorBudgetExceededError("retained_collectors", RETAINED_STATE_LIMIT_BYTES);
}
const bytes = byteLength(key);
chargeCallState(bytes);
deferredCalls.set(key, bytes);
};
const sanitizeReasoningItem = (
item: JsonRecord,
tracked: TrackedItem,
): void => {
if (item.type !== "reasoning") return;
const encrypted = typeof item.encrypted_content === "string";
tracked.encryptedReasoning ||= encrypted;
if (encrypted) delete item.encrypted_content;
if (tracked.encryptedReasoning) {
const summary = Array.isArray(item.summary) ? item.summary : [];
const hasPlaintextSummary = summary.some(part =>
isRecord(part)
&& part.type === "summary_text"
&& typeof part.text === "string"
&& part.text.length > 0);
if (!hasPlaintextSummary) item.summary = [{ type: "summary_text", text: "" }];
if (!Array.isArray(item.content)) item.content = [];
}
};
const normalizeNestedItem = (item: JsonRecord, outputIndex: number): void => {
const candidateId = typeof item.id === "string" ? item.id : undefined;
if (candidateId === undefined) return;
const itemType = typeof item.type === "string" ? item.type : undefined;
const tracked = rememberItem(
outputIndex,
candidateId,
itemType,
itemType === "reasoning" && typeof item.encrypted_content === "string",
);
item.id = tracked.id;
sanitizeReasoningItem(item, tracked);
};
const normalizeSequence = (event: JsonRecord): void => {
if (typeof event.sequence_number !== "number" || !Number.isFinite(event.sequence_number)) return;
event.sequence_number = nextSequenceNumber++;
};
const dispose = (): void => {
if (disposed) return;
disposed = true;
if (itemStateBytes > 0) budget?.releaseRetained(itemStateBytes, { kind: "item_ids" });
if (callStateBytes > 0) budget?.releaseRetained(callStateBytes, { kind: "retained_collectors" });
items.clear();
deferredCalls.clear();
responseId = undefined;
itemStateBytes = 0;
callStateBytes = 0;
itemTrackingTainted = false;
};
const rewrite: SseBlockRewrite = (block) => {
const payload = sseDataPayload(block);
if (payload === null || payload === "[DONE]") return [block];
let event: unknown;
try {
event = JSON.parse(payload);
} catch {
return [block];
}
if (!isRecord(event)) return [block];
if (typeof event.obfuscation === "string") delete event.obfuscation;
const type = event.type;
const outputIndex = outputIndexOf(event.output_index);
const deltaKind = callKindForDelta(type);
const deferToolDelta = deltaKind !== undefined
&& outputIndex !== undefined;
if (isRecord(event.response) && typeof event.response.id === "string") {
event.response.id = rememberResponseId(event.response.id);
}
if (outputIndex !== undefined && isRecord(event.item)) {
normalizeNestedItem(event.item, outputIndex);
}
// A deferred delta is not client-visible, so it must not establish the
// public item id if a malformed provider sends it before output_item.added.
if (!deferToolDelta && outputIndex !== undefined && typeof event.item_id === "string") {
const tracked = rememberItem(outputIndex, event.item_id);
event.item_id = tracked.id;
}
if (type === "response.completed" && isRecord(event.response) && Array.isArray(event.response.output)) {
event.response.output.forEach((item, index) => {
if (isRecord(item)) normalizeNestedItem(item, index);
});
}
if (typeof type === "string" && type.startsWith("response.reasoning")) {
if (typeof event.encrypted_content === "string") delete event.encrypted_content;
// `encrypted_content` is opaque replay state; summary delta/text fields
// are a separate, potentially readable part of the public Responses
// contract and must survive when Copilot provides them.
}
if (deferToolDelta) {
rememberDeferredCall(callKey(deltaKind, outputIndex));
// The OpenAI `obfuscation` field is padding, not a decryption key. Defer
// every Copilot tool fragment anyway: mixed padded/unpadded fragments and
// rotating ids cannot then produce duplicate or irreconcilable input.
// `.done` carries the authoritative complete value, which is emitted as
// one canonical delta immediately before the original `.done` event.
return [];
}
const emitted: Array<{ event: JsonRecord; synthetic: boolean }> = [];
const doneKind = callKindForDone(type);
if (doneKind !== undefined && outputIndex !== undefined) {
const key = callKey(doneKind, outputIndex);
if (releaseDeferredCall(key)) {
emitted.push({
synthetic: true,
event: {
type: deltaTypeFor(doneKind),
output_index: outputIndex,
...(typeof event.item_id === "string" ? { item_id: event.item_id } : {}),
...(typeof event.sequence_number === "number" ? { sequence_number: event.sequence_number } : {}),
delta: completeValueFor(doneKind, event),
},
});
}
}
emitted.push({ event, synthetic: false });
for (const entry of emitted) normalizeSequence(entry.event);
return emitted.map(entry => entry.synthetic
? syntheticJsonBlock(block, entry.event)
: rewriteJsonBlock(block, entry.event));
};
rewrite.dispose = dispose;
return rewrite;
}