UNPKG

@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
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); }, }); }