@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
207 lines (202 loc) • 9.56 kB
text/typescript
import { MessagesSseFrameContext, messagesSseFrameHooks, messagesSseLocalFrame } from "../lib/messages-sse-error-presentation";
import { anthropicErrorBody } from "../claude/outbound";
import { redactSecretString } from "../lib/redact";
import { sseFieldValue } from "../lib/sse-decoder";
import { TRANSLATOR_MAX_SSE_EVENT_BYTES, type TranslatorBudget } from "../lib/translator-budget";
import { UNDECLARED_TOOL_CALL_ERROR_CODE, undeclaredToolCallMessage } from "./responses-undeclared-tool-guard";
import { createSseBlockBuffer, sseDataPayload } from "./sse-payload-rewrite";
type Rec = Record<string, unknown>;
const isRec = (value: unknown): value is Rec => value !== null && typeof value === "object" && !Array.isArray(value);
const NO_DECLARED_TOOLS: ReadonlySet<string> = new Set();
/** Inline system-message definitions extend an otherwise empty native catalog. */
export function nativeMessagesInlineToolNames(body: Rec): ReadonlySet<string> {
const definitions = new Set<string>();
const active = new Set<string>();
if (!Array.isArray(body.messages)) return active;
for (const message of body.messages) {
if (!isRec(message) || message.role !== "system" || !Array.isArray(message.content)) continue;
for (const block of message.content) {
if (!isRec(block) || !isRec(block.tool)) continue;
const tool = block.tool;
if (block.type === "tool_addition" && tool.type === "tool_definition" && isRec(tool.definition)
&& typeof tool.definition.name === "string" && tool.definition.name.length > 0) {
definitions.add(tool.definition.name);
active.add(tool.definition.name);
} else if (tool.type === "tool_reference" && typeof tool.name === "string") {
if (block.type === "tool_addition" && definitions.has(tool.name)) active.add(tool.name);
// Like native admission, only a permanent removal withdraws a declaration.
if (block.type === "tool_removal" && (message.clear_at === undefined || message.clear_at === "never")) active.delete(tool.name);
}
}
}
return active;
}
/** Inspect only native message content; opaque extension fields do not carry client calls. */
export function nativeMessagesClientToolName(value: unknown, declared: ReadonlySet<string> = NO_DECLARED_TOOLS): string | undefined {
if (!isRec(value)) return undefined;
const content = Array.isArray(value.content) ? value.content : [];
const block = content.find(item => isRec(item) && item.type === "tool_use"
&& (typeof item.name !== "string" || !declared.has(item.name)));
if (isRec(block)) return typeof block.name === "string" ? block.name : "<unnamed>";
return undefined;
}
/** Used only when the current native request explicitly declares no client tools. */
export function guardNativeMessagesEmptyToolCatalog(
source: ReadableStream<Uint8Array>,
budget: TranslatorBudget,
onRefusal: (message: string) => void,
declared: ReadonlySet<string> = NO_DECLARED_TOOLS,
frames?: MessagesSseFrameContext,
): ReadableStream<Uint8Array> {
const reader = source.getReader();
const hooks = frames ? messagesSseFrameHooks(frames) : undefined;
const decoder = new TextDecoder();
const encoder = new TextEncoder();
const scope = { kind: "live_transient" as const };
const buffer = createSseBlockBuffer(budget, bytes => {
if (bytes > TRANSLATOR_MAX_SSE_EVENT_BYTES) throw new Error("upstream SSE event exceeded the safe limit");
});
// Hosted tools share input_json_delta with client tools, but cannot grant client authority.
const permittedInputBlocks = new Set<number>();
let queuedBytes = 0;
let settled = false;
let pendingLineFeed = false;
const releaseQueued = () => {
budget.releaseRetained(queuedBytes, scope);
queuedBytes = 0;
};
const clear = () => {
hooks?.dispose();
buffer.clear();
budget.releaseRetained(permittedInputBlocks.size * 32, scope);
permittedInputBlocks.clear();
};
const enqueue = (controller: ReadableStreamDefaultController<Uint8Array>, text: string, original?: string, refusal = false) => {
const bytes = Buffer.byteLength(text);
const reservation = budget.reserveTransient(bytes, scope);
try {
const encoded = encoder.encode(text);
if (refusal) frames?.register(encoded, { client: messagesSseLocalFrame("guard", "") });
else if (original !== undefined) hooks?.output(original, encoded);
controller.enqueue(encoded);
reservation.commitRetained();
queuedBytes += bytes;
} catch (error) {
reservation.release();
throw error;
}
};
const cancelReader = (reason?: unknown) => {
void reader.cancel(reason).catch(() => {});
};
const process = (controller: ReadableStreamDefaultController<Uint8Array>, block: string, delimiter: string) => {
const payload = sseDataPayload(block);
let data: unknown;
let terminal = false;
try { data = payload === null ? undefined : JSON.parse(payload); } catch {
// The buffered Messages collector concatenates data lines without separators. Inspect
// that representation too, so an invalid SSE split cannot become a valid folded tool call.
try { data = payload === null ? undefined : JSON.parse(payload.replace(/\n/g, "")); } catch { /* preserve opaque frames */ }
}
if (isRec(data)) {
const eventName = block.split(/\r\n|\r|\n/).map(line => sseFieldValue(line, "event"))
.filter(value => value !== null).at(-1)?.trim();
// Stream clients use the payload type; the buffered collector uses the event field.
const isEvent = (type: string) => data.type === type || eventName === type;
terminal = isEvent("message_stop") || isEvent("error");
let name = isEvent("message_start") ? nativeMessagesClientToolName(data.message, declared) : undefined;
if (isEvent("content_block_start") && isRec(data.content_block) && data.content_block.type === "tool_use"
&& (typeof data.content_block.name !== "string" || !declared.has(data.content_block.name))) {
name ??= typeof data.content_block.name === "string" ? data.content_block.name : "<unnamed>";
}
const index = typeof data.index === "number" && Number.isSafeInteger(data.index) ? data.index : undefined;
if (isEvent("content_block_delta") && isRec(data.delta) && data.delta.type === "input_json_delta"
&& (index === undefined || !permittedInputBlocks.has(index))) name ??= "<unnamed>";
if (name !== undefined) {
clear();
const message = redactSecretString(undeclaredToolCallMessage());
onRefusal(message);
enqueue(controller, `event: error\ndata: ${JSON.stringify(anthropicErrorBody(502, message, "api_error", UNDECLARED_TOOL_CALL_ERROR_CODE))}\n\n`, undefined, true);
settled = true;
cancelReader(new Error(message));
controller.close();
return;
}
if (isEvent("content_block_start") && index !== undefined && isRec(data.content_block)) {
if (permittedInputBlocks.delete(index)) budget.releaseRetained(32, scope);
if (data.content_block.type === "server_tool_use" || data.content_block.type === "mcp_tool_use"
|| data.content_block.type === "tool_use" && typeof data.content_block.name === "string" && declared.has(data.content_block.name)) {
budget.chargeRetained(32, scope);
permittedInputBlocks.add(index);
}
} else if (isEvent("content_block_stop") && index !== undefined && permittedInputBlocks.delete(index)) {
budget.releaseRetained(32, scope);
}
}
const frame = block + delimiter;
enqueue(controller, frame, frame);
if (terminal) {
settled = true;
clear();
cancelReader();
controller.close();
}
};
return new ReadableStream<Uint8Array>({
async pull(controller) {
releaseQueued();
if (settled) return;
try {
for (;;) {
const block = buffer.next();
if (block) {
pendingLineFeed = block.delimiter.endsWith("\r") && buffer.isEmpty();
buffer.compact();
process(controller, block.block, block.delimiter);
return;
}
const { done, value } = await reader.read();
if (settled) return;
if (!done) {
hooks?.input(value, buffer.isEmpty(), !buffer.isEmpty() && buffer.endsWithLineFeed(), pendingLineFeed);
const fragment = decoder.decode(value, { stream: true });
if (pendingLineFeed && fragment.length > 0) {
pendingLineFeed = false;
if (fragment.startsWith("\n")) {
// This LF extends an emitted delimiter and carries no frame origin.
buffer.append(fragment.slice(1));
enqueue(controller, "\n");
return;
}
}
buffer.append(fragment);
continue;
}
buffer.append(decoder.decode());
const tail = buffer.tail();
if (tail) process(controller, tail, "");
if (!settled) {
settled = true;
clear();
controller.close();
}
return;
}
} catch (error) {
if (settled) return;
settled = true;
clear();
cancelReader(error);
controller.error(error);
} finally {
if (settled) releaseQueued();
}
},
cancel(reason) {
settled = true;
clear();
releaseQueued();
return reader.cancel(reason);
},
});
}