@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
99 lines (97 loc) • 3.93 kB
text/typescript
import type { AdapterEvent } from "../types";
import {
isTranslatorBudgetExceededError,
releaseTranslatedEvent,
retainTranslatedEvent,
type TranslatorBudget,
} from "../lib/translator-budget";
/**
* Cognition signs reasoning after text/tools. Claude Code treats a trailing empty
* thinking block as its final result, so Messages needs reasoning before content.
* Consume after raw-event preflight and drain on demand, avoiding a queue burst.
*/
export async function* orderDevinMessagesOutput(
source: AsyncIterable<AdapterEvent>,
budget: TranslatorBudget,
signal: AbortSignal,
abortProducer: () => void,
): AsyncGenerator<AdapterEvent> {
const held: Array<AdapterEvent | undefined> = [];
let cancelled = signal.aborted;
let terminalDelivered = false;
let delivering: AdapterEvent | undefined;
const release = () => {
for (const event of held) if (event) releaseTranslatedEvent(event, budget);
held.length = 0;
if (delivering) releaseTranslatedEvent(delivering, budget);
};
const cancel = () => { cancelled = true; release(); };
signal.addEventListener("abort", cancel, { once: true });
const cancelledTerminal = (event: AdapterEvent): AdapterEvent => {
if (event.type !== "done" && event.type !== "incomplete") return event;
return { type: "error", status: 499, message: "client closed request", retryable: false,
...(event.usage ? { usage: event.usage } : {}) };
};
async function* drain() {
for (let index = 0; index < held.length && !cancelled; index++) {
delivering = held[index];
held[index] = undefined;
try {
if (delivering) {
terminalDelivered = delivering.type === "done" || delivering.type === "error" || delivering.type === "incomplete";
yield delivering;
}
}
finally {
if (delivering) releaseTranslatedEvent(delivering, budget);
delivering = undefined;
}
}
held.length = 0;
}
try {
for await (const event of source) {
const terminal = event.type === "done" || event.type === "error" || event.type === "incomplete";
if (cancelled) {
// The adapter's cancellation terminal retains its measured usage. Client
// stream cancellation instead returns this iterator and stops consumption.
if (terminal) { yield cancelledTerminal(event); return; }
continue;
}
if (event.type === "heartbeat" || event.type === "thinking_delta"
|| event.type === "thinking_signature" || event.type === "redacted_thinking"
|| event.type === "reasoning_raw_delta" || event.type === "kiro_redacted_reasoning") {
yield event;
continue;
}
// Retention owns a snapshot, including nested usage, so later producer or
// consumer mutations cannot change the bytes measured by the budget.
const copy = structuredClone(event);
try {
retainTranslatedEvent(copy, budget, held.at(-1));
held.push(copy);
} catch (error) {
if (!isTranslatorBudgetExceededError(error)) throw error;
release();
// Stop only the producer: aborting the request signal here would let the
// hosted-search loop replace the typed overflow with a client-cancel error.
abortProducer();
yield { type: "error", status: 413, errorType: "request_too_large",
code: "translation_buffer_limit", message: error.message };
return;
}
if (terminal) {
yield* drain();
if (cancelled && !terminalDelivered) yield cancelledTerminal(event);
return;
}
// Raw preflight already observed real output; feed the stream watchdog while
// the answer waits for its signature. Original heartbeats stay verbatim.
yield { type: "heartbeat" };
}
if (!cancelled) yield* drain();
} finally {
signal.removeEventListener("abort", cancel);
release();
}
}