@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
461 lines (442 loc) • 19.6 kB
text/typescript
import type { TranslatorBudget } from "../lib/translator-budget";
import {
mayBecomePatchEnvelope,
normalizeApplyPatchDelimiters,
stableCanonicalPatchPrefix,
} from "../responses/apply-patch-envelope";
import { compileCodeModeHelperInput, resolveCodeModeHelperName } from "../responses/code-mode-helper-compat";
import { mayBecomeCodeModeShellInput } from "../responses/code-mode-shell-input";
import { ProgressiveFreeformInputReader } from "../responses/progressive-freeform-input";
import { declaresCodeModeExec } from "../types/tools";
import {
customToolItemId,
restoreRoutedCustomCalls,
routedCustomToolTargetName,
routedCustomToolWireName,
unwrapRoutedCustomToolArguments,
} from "../responses/custom-tool-compat";
import {
replaceSseDataPayload,
splitSseBlock,
sseDataPayload,
type SseBlockRewrite,
} from "./sse-payload-rewrite";
function isPlainObject(value: unknown): value is Record<string, unknown> {
return !!value && typeof value === "object" && !Array.isArray(value);
}
function replaceSseEventName(block: string, type: string): string {
const { newline, lines } = splitSseBlock(block);
let replaced = false;
const next = lines.map(line => {
if (!replaced && line.startsWith("event:")) {
replaced = true;
return `event: ${type}`;
}
return line;
});
return next.join(newline);
}
type OpenCustomCall = {
argumentsText: string;
argumentsTail: string;
emittedInput: string;
canonicalPatchProgress: boolean;
retainedBytes: number;
// Resumes across deltas so the growing arguments are decoded once rather than once per delta.
freeformReader?: ProgressiveFreeformInputReader;
};
export class RoutedCustomToolProgressError extends Error {
constructor() {
super("routed custom tool progress disagreed with authoritative completion");
this.name = "RoutedCustomToolProgressError";
}
}
type PendingArgumentBlock = {
block: string;
itemId?: string;
outputIndex?: number;
retainedBytes: number;
};
export function createRoutedCustomToolRestoreBlockRewrite(
names: ReadonlySet<string>,
budget?: TranslatorBudget,
repairNames: ReadonlySet<string> = new Set(),
declaredNames?: ReadonlySet<string>,
): SseBlockRewrite {
const itemNames = new Map<string, { name: string; aliased: boolean; namespace?: string }>();
// Native helper aliases and genuine bare code-mode exec calls share completion repair.
const customExecItemNames = new Map<string, string>();
const repairItemNames = new Map<string, string>();
const ordinaryItemIds = new Set<string>();
const openCalls = new Map<string, OpenCustomCall>();
let pendingArguments: PendingArgumentBlock[] = [];
let disposed = false;
const emptyOpenCall = (): OpenCustomCall => ({
argumentsText: "",
argumentsTail: "",
emittedInput: "",
canonicalPatchProgress: false,
retainedBytes: 0,
});
const releaseCall = (itemId: string): void => {
const open = openCalls.get(itemId);
if (!open) return;
if (open.retainedBytes > 0) {
budget?.releaseRetained(open.retainedBytes, { kind: "retained_collectors" });
}
openCalls.delete(itemId);
};
const releaseAll = (): void => {
if (disposed) return;
disposed = true;
for (const itemId of openCalls.keys()) releaseCall(itemId);
const pendingBytes = pendingArguments.reduce((total, pending) => total + pending.retainedBytes, 0);
if (pendingBytes > 0) {
budget?.releaseRetained(pendingBytes, { kind: "retained_collectors" });
}
pendingArguments = [];
itemNames.clear();
customExecItemNames.clear();
repairItemNames.clear();
ordinaryItemIds.clear();
};
const authoritativeInput = (itemId: string, source: string): string => {
const itemName = itemNames.get(itemId);
const helper = itemName?.aliased
? itemName.name
: resolveCodeModeHelperName(
undefined,
itemName?.name ?? "",
source,
itemName?.namespace,
declaredNames,
);
return helper
? compileCodeModeHelperInput(source, helper, itemName?.name ?? "")
: unwrapRoutedCustomToolArguments(source, itemName?.name ?? "", itemName?.namespace);
};
const assertProgressMatchesCompletion = (itemId: string, source: string): void => {
const open = openCalls.get(itemId);
if (!open?.canonicalPatchProgress) return;
const finalInput = authoritativeInput(itemId, source);
if (finalInput.startsWith(open.emittedInput)) return;
releaseAll();
throw new RoutedCustomToolProgressError();
};
const retainPendingArgument = (
block: string,
itemId: string | undefined,
outputIndex: number | undefined,
): void => {
const retainedBytes = Buffer.byteLength(block, "utf8");
if (retainedBytes > 0) budget?.chargeRetained(retainedBytes, { kind: "retained_collectors" });
pendingArguments.push({ block, itemId, outputIndex, retainedBytes });
};
const takePendingArguments = (
itemId: string | undefined,
outputIndex: number | undefined,
): string[] => {
const matched: PendingArgumentBlock[] = [];
const remaining: PendingArgumentBlock[] = [];
for (const pending of pendingArguments) {
const matches = pending.itemId !== undefined
? itemId !== undefined && pending.itemId === itemId
: outputIndex !== undefined && pending.outputIndex === outputIndex;
(matches ? matched : remaining).push(pending);
}
pendingArguments = remaining;
const retainedBytes = matched.reduce((total, pending) => total + pending.retainedBytes, 0);
if (retainedBytes > 0) {
budget?.releaseRetained(retainedBytes, { kind: "retained_collectors" });
}
// Index-matched entries carry no item id. Stamp the resolved id so replay
// classifies the event instead of buffering it a second time.
return matched.map(pending => {
if (pending.itemId !== undefined || itemId === undefined) return pending.block;
const payload = sseDataPayload(pending.block);
if (payload === null) return pending.block;
try {
const parsed: unknown = JSON.parse(payload);
if (!isPlainObject(parsed)) return pending.block;
return replaceSseDataPayload(pending.block, JSON.stringify({ ...parsed, item_id: itemId }));
} catch {
return pending.block;
}
});
};
const rewrite: SseBlockRewrite = (block: string): readonly string[] => {
if (disposed) return [block];
const payload = sseDataPayload(block);
if (payload === null || payload === "[DONE]") return [block];
let parsed: unknown;
try {
parsed = JSON.parse(payload);
} catch {
return [block];
}
if (!isPlainObject(parsed)) return [block];
const type = typeof parsed.type === "string" ? parsed.type : "";
const outputIndex = typeof parsed.output_index === "number"
&& Number.isInteger(parsed.output_index)
&& parsed.output_index >= 0
? parsed.output_index
: undefined;
if (
(type === "response.output_item.added" || type === "response.output_item.done")
&& isPlainObject(parsed.item)
&& parsed.item.type === "custom_tool_call"
&& typeof parsed.item.name === "string"
) {
const upstreamItemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
const wireName = routedCustomToolWireName(parsed.item);
const targetName = routedCustomToolTargetName(parsed.item, names, declaredNames);
const aliased = targetName !== undefined && targetName !== wireName;
const codeModeExec = targetName === "exec" && parsed.item.name === "exec"
&& parsed.item.namespace === undefined && declaresCodeModeExec(declaredNames);
if (upstreamItemId && (aliased || codeModeExec)) {
customExecItemNames.set(upstreamItemId, parsed.item.name);
if (type === "response.output_item.added") {
openCalls.set(upstreamItemId, emptyOpenCall());
}
}
const repairable = wireName !== undefined && repairNames.has(wireName);
if (upstreamItemId && repairable) repairItemNames.set(upstreamItemId, parsed.item.name);
const restored = repairable || aliased || codeModeExec
? restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames)
: { value: parsed, changed: false };
if (type === "response.output_item.done" && upstreamItemId) releaseCall(upstreamItemId);
return restored.changed
? [replaceSseDataPayload(block, JSON.stringify(restored.value))]
: [block];
}
if (
(type === "response.output_item.added" || type === "response.output_item.done")
&& isPlainObject(parsed.item)
&& parsed.item.type === "function_call"
&& typeof parsed.item.name === "string"
) {
const upstreamItemId = typeof parsed.item.id === "string" ? parsed.item.id : undefined;
const targetName = routedCustomToolTargetName(parsed.item, names, declaredNames);
const routed = targetName !== undefined;
const wireName = routedCustomToolWireName(parsed.item);
if (upstreamItemId) {
if (routed) {
itemNames.set(upstreamItemId, {
name: parsed.item.name,
aliased: targetName !== wireName,
...(typeof parsed.item.namespace === "string" ? { namespace: parsed.item.namespace } : {}),
});
ordinaryItemIds.delete(upstreamItemId);
} else {
ordinaryItemIds.add(upstreamItemId);
}
if (routed && type === "response.output_item.added") {
openCalls.set(upstreamItemId, emptyOpenCall());
}
}
const pending = takePendingArguments(upstreamItemId, outputIndex);
if (!routed) {
if (type === "response.output_item.done" && upstreamItemId) ordinaryItemIds.delete(upstreamItemId);
return [...pending, block];
}
if (upstreamItemId && pending.length > 0 && !openCalls.has(upstreamItemId)) {
openCalls.set(upstreamItemId, emptyOpenCall());
}
if (
type === "response.output_item.done"
&& upstreamItemId
&& typeof parsed.item.arguments === "string"
) {
assertProgressMatchesCompletion(upstreamItemId, parsed.item.arguments);
}
const restored = restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames);
const restoredBlock = restored.changed
? replaceSseDataPayload(block, JSON.stringify(restored.value))
: block;
const replayed = pending.flatMap(pendingBlock => rewrite(pendingBlock));
if (type === "response.output_item.done" && upstreamItemId) releaseCall(upstreamItemId);
return type === "response.output_item.added"
? [restoredBlock, ...replayed]
: [...replayed, restoredBlock];
}
const upstreamItemId = typeof parsed.item_id === "string" ? parsed.item_id : undefined;
if (
type === "response.custom_tool_call_input.delta"
&& upstreamItemId
&& customExecItemNames.has(upstreamItemId)
) {
const open = openCalls.get(upstreamItemId) ?? emptyOpenCall();
const delta = typeof parsed.delta === "string" ? parsed.delta : "";
const deltaBytes = Buffer.byteLength(delta, "utf8");
if (deltaBytes > 0) budget?.chargeRetained(deltaBytes, { kind: "retained_collectors" });
open.argumentsText += delta;
open.argumentsTail = (open.argumentsTail + delta).slice(-64);
open.retainedBytes += deltaBytes;
openCalls.set(upstreamItemId, open);
if (customExecItemNames.get(upstreamItemId) !== "exec"
|| mayBecomePatchEnvelope(open.argumentsText)
// JSON.parse accepts whitespace, escaped keys and arbitrary property order.
// Any object prefix may still wrap a patch; keep it until authoritative completion.
|| open.argumentsText.trimStart() === ""
|| open.argumentsText.trimStart().startsWith("{")) return [];
// If a held prefix turns out to be ordinary JavaScript, release the entire
// un-emitted suffix. Native custom input remains byte-exact.
const inputDelta = open.argumentsText.slice(open.emittedInput.length);
open.emittedInput = open.argumentsText;
return inputDelta ? [replaceSseDataPayload(block, JSON.stringify({ ...parsed, delta: inputDelta }))] : [];
}
if (
type === "response.custom_tool_call_input.done"
&& upstreamItemId
&& customExecItemNames.has(upstreamItemId)
) {
const source = typeof parsed.input === "string"
? parsed.input
: openCalls.get(upstreamItemId)?.argumentsText ?? "";
const name = customExecItemNames.get(upstreamItemId)!;
const helper = name === "exec"
? resolveCodeModeHelperName(undefined, name, source, undefined, declaredNames)
: name;
releaseCall(upstreamItemId);
return [replaceSseDataPayload(block, JSON.stringify({
...parsed,
input: helper ? compileCodeModeHelperInput(source, helper, name) : source,
}))];
}
if (
type === "response.custom_tool_call_input.done"
&& upstreamItemId
&& repairItemNames.has(upstreamItemId)
&& typeof parsed.input === "string"
) {
const input = normalizeApplyPatchDelimiters(parsed.input);
if (input !== parsed.input) {
return [replaceSseDataPayload(block, JSON.stringify({ ...parsed, input }))];
}
}
const argumentEvent = type === "response.function_call_arguments.delta"
|| type === "response.function_call_arguments.done";
if (argumentEvent && (!upstreamItemId || (!itemNames.has(upstreamItemId) && !ordinaryItemIds.has(upstreamItemId)))) {
retainPendingArgument(block, upstreamItemId, outputIndex);
return [];
}
if (
type === "response.function_call_arguments.delta"
&& upstreamItemId
&& itemNames.has(upstreamItemId)
) {
const open = openCalls.get(upstreamItemId) ?? emptyOpenCall();
const delta = typeof parsed.delta === "string" ? parsed.delta : "";
const deltaBytes = Buffer.byteLength(delta, "utf8");
if (deltaBytes > 0) budget?.chargeRetained(deltaBytes, { kind: "retained_collectors" });
open.argumentsText += delta;
open.argumentsTail = (open.argumentsTail + delta).slice(-64);
open.retainedBytes += deltaBytes;
openCalls.set(upstreamItemId, open);
// A helper alias will become JavaScript at completion, never raw patch/JSON.
if (itemNames.get(upstreamItemId)?.aliased) return [];
const itemName = itemNames.get(upstreamItemId);
const ownsFreeformGrammar = itemName?.namespace === undefined
|| itemName?.namespace === "functions";
open.freeformReader ??= new ProgressiveFreeformInputReader();
const fullInput = open.freeformReader.update(
open.argumentsText,
ownsFreeformGrammar ? itemName?.name ?? "" : "",
);
if (fullInput === null) return [];
// This routed path historically holds every unrecognized JSON object until done.
// The shared decoder streams ordinary raw input, so retain the stricter routed rule
// when no recognized wrapper transformed the accumulated object.
if (fullInput === open.argumentsText && open.argumentsText.trimStart().startsWith("{")) return [];
// Hold a buffer that could still become a complete patch envelope, for either of the two
// reasons completion rewrites one. Both are the same rewind this path forbids, and both
// mirror `src/bridge/sse.ts`.
//
// `exec`: the done event recompiles such a body into an apply_patch helper call.
// `apply_patch`: `normalizeApplyPatchDelimiters` rewrites a decorated
// `*** Begin Patch ***` envelope at completion, so the decorated markers would be
// published and then replaced by the normalized ones. Before the shared decoder, this
// path held every non-canonical shape and so never reached that case; now that ordinary
// raw input streams, the second reason has to be stated explicitly.
const mayCompile = declaresCodeModeExec(declaredNames)
&& itemName?.namespace === undefined
&& itemName?.name === "exec";
const mayNormalize = ownsFreeformGrammar && itemName?.name === "apply_patch";
if (mayCompile && mayBecomePatchEnvelope(fullInput)) return [];
let streamInput = fullInput;
if (mayNormalize && mayBecomePatchEnvelope(fullInput)) {
const stablePrefix = stableCanonicalPatchPrefix(
fullInput,
fullInput === open.argumentsText ? open.argumentsTail : fullInput.slice(-64),
open.canonicalPatchProgress,
);
if (stablePrefix === null) return [];
streamInput = stablePrefix;
if (stablePrefix.length > 0) open.canonicalPatchProgress = true;
}
if (mayCompile && mayBecomeCodeModeShellInput(open.argumentsText, fullInput)) return [];
if (!streamInput.startsWith(open.emittedInput) || streamInput.length === open.emittedInput.length) return [];
const inputDelta = streamInput.slice(open.emittedInput.length);
open.emittedInput = streamInput;
const nextType = "response.custom_tool_call_input.delta";
const next = {
...parsed,
type: nextType,
item_id: customToolItemId(upstreamItemId),
delta: inputDelta,
};
return [replaceSseDataPayload(replaceSseEventName(block, nextType), JSON.stringify(next))];
}
if (
type === "response.function_call_arguments.done"
&& upstreamItemId
&& itemNames.has(upstreamItemId)
) {
const nextType = "response.custom_tool_call_input.done";
const source = typeof parsed.arguments === "string"
? parsed.arguments
: openCalls.get(upstreamItemId)?.argumentsText ?? "";
const { arguments: _arguments, ...rest } = parsed;
const itemName = itemNames.get(upstreamItemId);
// Name-based alias first; otherwise a raw patch envelope submitted as the `exec` body
// resolves to the same apply_patch helper (devlog/_plan/260905_apply_patch_envelope_gap).
const helper = itemName?.aliased
? itemName.name
: resolveCodeModeHelperName(undefined, itemName?.name ?? "", source, itemName?.namespace, declaredNames);
assertProgressMatchesCompletion(upstreamItemId, source);
const next = {
...rest,
type: nextType,
item_id: customToolItemId(upstreamItemId),
input: helper
? compileCodeModeHelperInput(source, helper, itemName?.name ?? "")
: unwrapRoutedCustomToolArguments(source, itemName?.name ?? "", itemName?.namespace),
};
return [replaceSseDataPayload(replaceSseEventName(block, nextType), JSON.stringify(next))];
}
const terminal = type === "response.completed" || type === "response.failed" || type === "response.incomplete";
if (
type === "response.completed"
&& isPlainObject(parsed.response)
&& Array.isArray(parsed.response.output)
) {
for (const item of parsed.response.output) {
if (
isPlainObject(item)
&& item.type === "function_call"
&& typeof item.id === "string"
&& typeof item.arguments === "string"
) {
assertProgressMatchesCompletion(item.id, item.arguments);
}
}
}
const restored = restoreRoutedCustomCalls(parsed, names, repairNames, declaredNames);
if (terminal) releaseAll();
return restored.changed
? [replaceSseDataPayload(block, JSON.stringify(restored.value))]
: [block];
};
rewrite.dispose = releaseAll;
return rewrite;
}