@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
120 lines (109 loc) • 4.97 kB
text/typescript
import { createHash } from "node:crypto";
/**
* Anthropic rejects a `tool_use.id` longer than this. Collision disambiguation has to fit
* inside it too, which is why candidates are assembled from parts instead of sliced at the end.
*/
export const MAX_TOOL_CALL_ID_LENGTH = 64;
/** Hex characters of the deterministic tail. Fixed width: it is a discriminator, not a payload. */
const TOOL_CALL_ID_HASH_WIDTH = 8;
const CONFORMING_TOOL_CALL_ID = /^[a-zA-Z0-9_-]+$/;
/** An id Anthropic accepts as-is: right character set AND within the length bound. */
export function isConformingToolCallId(rawId: string): boolean {
return rawId.length > 0
&& rawId.length <= MAX_TOOL_CALL_ID_LENGTH
&& CONFORMING_TOOL_CALL_ID.test(rawId);
}
/**
* The parts a rewritten id is built from: the sanitized prefix and a deterministic tail
* derived from the raw id. Kept separate so collision handling can truncate the prefix
* without destroying the discriminator.
*/
function toolCallIdComponents(rawId: string | undefined): { cleaned: string; hash: string } | undefined {
const raw = rawId ?? "";
if (raw.length === 0) return undefined;
const cleaned = raw.replace(/[^a-zA-Z0-9_-]/g, "_");
const hash = createHash("sha256").update(raw).digest("hex").slice(0, TOOL_CALL_ID_HASH_WIDTH);
return { cleaned, hash };
}
/** Assemble `prefix_hash`, truncating only the prefix, leaving `reserve` characters spare. */
function fitToolCallId(cleaned: string, hash: string, reserve = 0): string {
const tail = `_${hash}`;
const room = MAX_TOOL_CALL_ID_LENGTH - reserve - tail.length;
return cleaned.slice(0, Math.max(1, room)) + tail;
}
/**
* Normalize a tool call id into the character set and length Anthropic accepts.
*
* This is the stateless view, kept for callers that only need the shape of one id. It is NOT
* injective on its own: `anthropicToolCallId("call:a")` returns something like `call_a_1f2e3d4c`,
* and a raw id that already equals that value is returned unchanged — two distinct sources, one
* wire id. Anything building a whole request must use {@link createToolCallIdAllocator}, which
* reserves the conforming ids first and resolves collisions.
*
* Returns `undefined` for an empty id. Callers must handle that rather than falling back to the
* raw value: restoring `""` puts an id on the wire that Anthropic rejects (#1767).
*/
export function anthropicToolCallId(rawId: string | undefined): string | undefined {
const raw = rawId ?? "";
if (raw.length === 0) return undefined;
if (isConformingToolCallId(raw)) return raw;
const parts = toolCallIdComponents(raw);
if (!parts) return undefined;
return fitToolCallId(parts.cleaned, parts.hash);
}
export type ToolCallIdAllocator = {
/** Claim an already-conforming source id so no rewrite can be handed the same value. */
reserve(rawId: string | undefined): void;
/** Wire id for a raw id, stable within the request. `undefined` means "not representable". */
allocate(rawId: string | undefined): string | undefined;
/** Wire id previously allocated for this raw id, without creating one. */
lookup(rawId: string | undefined): string | undefined;
};
/**
* Request-scoped raw-id to wire-id mapping.
*
* Two properties the stateless transform cannot provide:
*
* - **Injective.** Reserve every already-conforming id first, then allocate rewrites around them,
* appending a numeric suffix when a candidate is taken. Two distinct raw ids never share a wire id,
* including the case where one raw id already looks like another's normalized form, and including
* an ordinary 32-bit hash collision.
* - **Stable.** A tool result asks for the same raw id its call used and gets the same wire id, so
* call/result pairing survives normalization.
*/
export function createToolCallIdAllocator(): ToolCallIdAllocator {
const rawToWire = new Map<string, string>();
const occupied = new Set<string>();
return {
reserve(rawId) {
if (!rawId || rawToWire.has(rawId)) return;
if (!isConformingToolCallId(rawId)) return;
rawToWire.set(rawId, rawId);
occupied.add(rawId);
},
allocate(rawId) {
if (!rawId) return undefined;
const existing = rawToWire.get(rawId);
if (existing) return existing;
if (isConformingToolCallId(rawId) && !occupied.has(rawId)) {
rawToWire.set(rawId, rawId);
occupied.add(rawId);
return rawId;
}
const parts = toolCallIdComponents(rawId);
if (!parts) return undefined;
let candidate = fitToolCallId(parts.cleaned, parts.hash);
for (let n = 2; occupied.has(candidate); n++) {
const suffix = `_${n}`;
candidate = fitToolCallId(parts.cleaned, parts.hash, suffix.length) + suffix;
}
rawToWire.set(rawId, candidate);
occupied.add(candidate);
return candidate;
},
lookup(rawId) {
if (!rawId) return undefined;
return rawToWire.get(rawId);
},
};
}