Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
84 changes: 84 additions & 0 deletions src/codex-compact.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,84 @@
import { randomUUID } from "node:crypto";
import type { Session } from "./session.js";

export const CODEX_COMPACT_ID_PREFIX = "fc_bili_";
export const CODEX_COMPACT_SENTINEL = "bili:acp:";

const CODEX_UA_PREFIXES = ["codex_cli_rs/", "codex_exec/"];

export type CodexCompactMode = "intercept" | "pass";

// Read per-request (not cached at startup) so a running proxy can flip the
// kill-switch without a restart.
export function codexCompactMode(): CodexCompactMode {
const v = process.env.BILI_CODEX_COMPACT?.trim().toLowerCase();
return v === "intercept" ? "intercept" : "pass";
}

// The `originator` header is only sent for non-default thread originators, so
// the UA prefix (DEFAULT_ORIGINATOR in codex's default_client.rs) is the
// reliable client signal.
export function isCodexClient(headers: Record<string, string | string[] | undefined>): boolean {
const ua = headers["user-agent"];
if (!ua) return false;
const s = Array.isArray(ua) ? ua[0] : ua;
return typeof s === "string" && CODEX_UA_PREFIXES.some((p) => s.startsWith(p));
}

export function hasCompactionTrigger(input: unknown): boolean {
if (!Array.isArray(input)) return false;
const last = input[input.length - 1] as { type?: unknown } | undefined;
return last?.type === "compaction_trigger";
}

// Recognize a compaction item WE generated (id prefix or sentinel in the blob).
// Codex echoes it back in the next request; stripping it keeps the summary
// sourced from state (no double-count). Real OpenAI blobs carry neither marker,
// so they are left untouched.
export function isBiliCompactionItem(item: unknown): boolean {
const it = item as { type?: unknown; id?: unknown; encrypted_content?: unknown } | null;
if (!it || it.type !== "compaction") return false;
if (typeof it.id === "string" && it.id.startsWith(CODEX_COMPACT_ID_PREFIX)) return true;
if (typeof it.encrypted_content === "string" && it.encrypted_content.startsWith(CODEX_COMPACT_SENTINEL)) return true;
return false;
}

export function stripBiliCompactionItems<T>(input: T[]): T[] {
return input.filter((item) => !isBiliCompactionItem(item));
}

// Safety valve: forge ONLY when the transform succeeded, the steady-state
// context is below the 90% threshold (codex's own auto-compact point — above
// it, bili's ACP has failed to keep up and native compaction must backstop),
// and there is at least one active block (a real summary to hand off).
export function codexCompactGate(session: Session, effectiveLimit: number, transformOk: boolean): boolean {
if (!transformOk || effectiveLimit <= 0) return false;
if (session.stats.lastInputTokens >= effectiveLimit * 0.9) return false;
return session.state.blocks.some((b) => b.active);
}

// Minimal legal forged SSE stream for the trigger form: exactly one compaction
// output item + response.completed. Codex's parser (codex-api/src/sse/responses.rs)
// ignores every other event kind and requires response.completed to parse with
// id + usage{input_tokens,output_tokens,total_tokens}.
export function buildTriggerForgeSse(
summaryText: string,
usage: { inputTokens: number; outputTokens: number; totalTokens: number },
): string {
const compactionItem = {
type: "compaction",
id: `${CODEX_COMPACT_ID_PREFIX}${randomUUID()}`,
encrypted_content: `${CODEX_COMPACT_SENTINEL}${summaryText}`,
};
const completed = {
id: `resp_bili_${randomUUID()}`,
usage: {
input_tokens: usage.inputTokens,
output_tokens: usage.outputTokens,
total_tokens: usage.totalTokens,
},
};
const frame1 = `data: ${JSON.stringify({ type: "response.output_item.done", item: compactionItem })}\n\n`;
const frame2 = `data: ${JSON.stringify({ type: "response.completed", response: completed })}\n\n`;
return frame1 + frame2;
}
97 changes: 90 additions & 7 deletions src/server.ts
Original file line number Diff line number Diff line change
Expand Up @@ -53,6 +53,7 @@ import { defaultLogFile, stateDir, proxyOriginFile } from "./paths.js";
import { compressLoopResponsesJson } from "./compress-loop-responses.js";
import { runCompressLoop, pickAdapter } from "./loop/index.js";
import { sanitizeResponsesInputIds, dropWhitespaceResponsesMessages, normalizeResponsesMessageItems } from "./loop/adapter-responses.js";
import { codexCompactMode, isCodexClient, hasCompactionTrigger, stripBiliCompactionItems, codexCompactGate, buildTriggerForgeSse } from "./codex-compact.js";
import { rewriteOpenaiJsonResponse } from "./stream-openai.js";
import { rewriteResponsesJsonResponse } from "./stream-responses.js";
import { emitStreamError } from "./stream-error.js";
Expand Down Expand Up @@ -444,11 +445,15 @@ type Prepared = {
* rebuilt payload and compress-loop round must re-inject it. */
openaiSystemText?: string;
nudge?: NudgeDecision;
/** Effective compression prompts for this request (three-level cascade,
* defaults to the kernel's defaultPrompts). Carried so the compress loop
* in forward() rebuilds the SAME system prompt the request was prepared
* with. */
/** Effective compression prompts for this request (three-level cascade,
* defaults to the kernel's defaultPrompts). Carried so the compress loop
* in forward() rebuilds the SAME system prompt the request was prepared
* with. */
prompts?: Prompts;
/** Set when a codex native-compaction request was intercepted and a
* success response was forged locally (BILI_CODEX_COMPACT=intercept +
* gate passed). forward() serves `body` without contacting upstream. */
codexForge?: { kind: "endpoint" | "trigger"; body: string; contentType: string };
};


Expand Down Expand Up @@ -1047,7 +1052,7 @@ async function handle(
: protocol === "openai"
? prepareOpenai(parsed as OpenAIRequestBody, req, opts, core, reqConfig, reqPrompts, log, session, pluginMode)
: responsesCompact
? prepareResponsesCompact(bodyBuffer, parsed as ResponsesRequestBody, session)
? prepareResponsesCompact(bodyBuffer, parsed as ResponsesRequestBody, session, req, core, reqConfig, log)
: prepareResponses(parsed as ResponsesRequestBody, req, opts, core, reqConfig, reqPrompts, log, session, responsesIdentity!, pluginMode, upstreamOrigin);
prepared = runPrepare();
if (!countTokens && !responsesCompact) {
Expand Down Expand Up @@ -1375,12 +1380,24 @@ function prepareResponses(
log("info", `[${sessionId}] reconciled ACP state after native Responses compact boundary`);
}

// A codex client echoes our forged compaction item back in the next request;
// drop it so the summary is sourced from state (no double-count). Real
// OpenAI blobs carry no bili marker and pass through untouched.
if (Array.isArray(parsed.input)) {
const cleaned = stripBiliCompactionItems(parsed.input);
if (cleaned.length !== parsed.input.length) {
log("info", `[${sessionId}] stripped ${parsed.input.length - cleaned.length} bili compaction item(s) echoed by codex`);
parsed.input = cleaned;
}
}

let processedMessages: CoreMessage[] = [];
let originalMessages: CoreMessage[] = [];
let nudge: NudgeDecision | undefined;
let responsesProjection: ResponsesProjection | undefined;
let rebuiltInput: ResponseInputItem[] | string = parsed.input;
let toolsOut = parsed.tools;
let transformOk = false;

// #242: over-long input item ids (poisoned rollouts) 400 upstream on every
// request; rewrite them to short deterministic ids before anything reads
Expand Down Expand Up @@ -1469,11 +1486,33 @@ function prepareResponses(
} catch {
}
}
transformOk = true;
} catch (err) {
log("warn", `[${sessionId}] kernel transform failed, forwarding unchanged: ${String(err)}`);
processedMessages = [];
}

// E2 trigger form: codex's native remote-compaction request (final input item
// is compaction_trigger). When the kill-switch is on, the client is codex, and
// the safety gate passes, forge a success SSE (one compaction item +
// response.completed) and skip upstream — a deterministic handoff to the ACP
// state instead of a foreign compaction blob.
let codexForge: Prepared["codexForge"] | undefined;
if (transformOk
&& codexCompactMode() === "intercept"
&& isCodexClient(req.headers)
&& hasCompactionTrigger(parsed.input)
&& codexCompactGate(session, config.modelContextLimit, transformOk)) {
const summaries = session.state.blocks.filter((b) => b.active).map((b) => b.summary);
const total = session.stats.lastInputTokens;
codexForge = {
kind: "trigger",
body: buildTriggerForgeSse(summaries.join("\n\n"), { inputTokens: total, outputTokens: 0, totalTokens: total }),
contentType: "text/event-stream",
};
log("info", `[${sessionId}] codex compact intercepted (trigger); forged SSE with ${summaries.length} block summary(s), upstream not contacted`);
}

const rebuilt: ResponsesRequestBody = { ...parsed, input: rebuiltInput, tools: toolsOut };
// Route with the upstream THIS request goes to — session.meta.upstreamOrigin
// is first-wins and would keep injecting pck toward a relay we switched
Expand Down Expand Up @@ -1527,6 +1566,7 @@ function prepareResponses(
responsesTextProtocol,
nudge,
prompts,
codexForge,
};
}

Expand Down Expand Up @@ -1576,9 +1616,17 @@ export function prepareCountTokens(
}
}

function prepareResponsesCompact(body: Buffer, parsed: ResponsesRequestBody, session: Session): Prepared {
function prepareResponsesCompact(
body: Buffer,
parsed: ResponsesRequestBody,
session: Session,
req: http.IncomingMessage,
core: CompressionCore,
config: Config,
log: (level: string, msg: string) => void,
): Prepared {
++session.stats.requests;
return {
const base: Prepared = {
body,
session,
processedMessages: [],
Expand All @@ -1588,6 +1636,33 @@ function prepareResponsesCompact(body: Buffer, parsed: ResponsesRequestBody, ses
compressInjected: false,
resetAfterSuccess: true,
};
if (codexCompactMode() !== "intercept" || !isCodexClient(req.headers) || !Array.isArray(parsed.input)) {
return base;
}
// E2 endpoint form: /responses/compact. When the gate passes, run the same
// fold pipeline as a normal turn and forge the compacted history as
// {"output": [...]} — a deterministic handoff to the ACP state instead of a
// foreign compaction blob.
const cleaned = stripBiliCompactionItems(parsed.input);
const forgeBody: ResponsesRequestBody = { ...parsed, input: cleaned };
let transformOk = false;
try {
const projection = responsesToCore(forgeBody);
const turn = core.processTurn({ messages: projection.msgs, state: session.state, config, tokenCount: session.stats.lastInputTokens, renderTags: process.env.ACP_RENDER_NONE ? "none" : "text-only" });
session.state = turn.state;
transformOk = true;
if (!codexCompactGate(session, config.modelContextLimit, transformOk)) return base;
const processed = stripKernelSummaries(turn.messages, turn.state);
const output = patchResponsesInput(projection, processed);
if (typeof output === "string") return base;
snapshotMessages(session, projection.msgs);
markDirty(session);
log("info", `[${session.id}] codex compact intercepted (endpoint); forged history with ${output.length} item(s), upstream not contacted`);
return { ...base, codexForge: { kind: "endpoint", body: JSON.stringify({ output }), contentType: "application/json" } };
} catch (err) {
log("warn", `[${session.id}] codex compact forge failed (${String(err)}); passing through to upstream`);
return base;
}
}

export function isChatGptCodexUpstream(upstream: string | undefined): boolean {
Expand Down Expand Up @@ -1867,6 +1942,14 @@ async function forward(
instanceId: string,
affinity?: string,
): Promise<void> {
// E2: a codex native-compaction request intercepted in prepare() carries a
// forged success response — serve it without contacting upstream.
if (prepared?.codexForge) {
log("info", `[${prepared.session.id}] codex compact served locally (${prepared.codexForge.kind}); upstream not contacted`);
res.writeHead(200, { "content-type": prepared.codexForge.contentType });
res.end(prepared.codexForge.body);
return;
}
// #300: stamp the chain marker ONLY when this instance actually processed
// the request (prepared !== null). A passthrough forward (prepared === null)
// must NOT claim processing — otherwise a downstream processing bili would
Expand Down
Loading
Loading