@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
75 lines (72 loc) • 3.75 kB
text/typescript
import { isConformingToolCallId, MAX_TOOL_CALL_ID_LENGTH } from "../tool-call-id";
import type { OcxMessage } from "../../types";
/**
* Remint a tool-call id the client's history already carries.
*
* Some upstreams mint tool-call ids deterministically per RESPONSE rather than per call: the same
* `call-0-0` on every turn of a conversation. Anthropic's wire requires `tool_use.id` to identify
* one call, and a client that has already stored that id for an earlier call cannot pair the new
* result to the new call — it drops one of them, the turn becomes an assistant message whose
* tool call has no result, and the model re-issues the same call forever.
*
* The first occurrence of an id is emitted byte-identical, so prompt-cache keys, reasoning-replay
* lookups, and every upstream that already mints unique ids stay untouched. Only a repeat — against
* the history the caller seeded, or against a call already emitted in this response — is rewritten,
* to the smallest unused suffix that still fits Anthropic's id bound.
*/
export function createToolCallIdReminter(reservedIds: Iterable<string>): (rawId: string) => string {
const occupied = new Set(reservedIds);
const nextSuffixByWidthAndPrefix = new Map<string, number>();
return rawId => {
if (!occupied.has(rawId)) {
occupied.add(rawId);
return rawId;
}
// A non-conforming source is sanitized, never dropped: the wire still needs an id, and the
// occupied check below covers a sanitized form that now equals some other call's id.
const base = isConformingToolCallId(rawId) ? rawId : rawId.replace(/[^a-zA-Z0-9_-]/g, "_");
for (let n = 2; ;) {
// Hyphen, not underscore: an id that extends another id as `<earlier>_<digits>` is parsed by
// at least one client as a batch sub-call of `<earlier>`, which pairs the second call's
// result to the first call. A `-<n>` suffix is in the same id family without that reading.
const suffix = `-${n}`;
// A wider suffix retains less of the base, so siblings that were separate at -9
// can converge at -10. Resume in the candidate's actual width/prefix domain.
const prefix = base.slice(0, Math.max(1, MAX_TOOL_CALL_ID_LENGTH - suffix.length));
const cursorKey = `${suffix.length}:${prefix}`;
const next = nextSuffixByWidthAndPrefix.get(cursorKey);
if (next !== undefined && next > n) { n = next; continue; }
const candidate = prefix + suffix;
nextSuffixByWidthAndPrefix.set(cursorKey, n + 1);
if (!occupied.has(candidate)) {
occupied.add(candidate);
return candidate;
}
n++;
}
};
}
/**
* Tool-call ids the client's own history has already fixed: every assistant tool call it kept, plus
* every tool result that answered one. A response repeating any of them is the collision this
* module exists for.
*
* Read from the client's history rather than from earlier responses because the client is the
* authority on uniqueness here: it is the side that drops duplicates, so the proxy cannot observe
* the ids it discarded — a dropped id only ever exists as the absence it caused. A Messages client
* sends the whole conversation on every turn, which is why one turn's history is a complete picture
* of the ids that may not be reused.
*/
export function reservedToolCallIdsFromHistory(messages: readonly OcxMessage[]): Set<string> {
const ids = new Set<string>();
for (const message of messages) {
if (message.role === "assistant") {
for (const part of message.content) {
if (part.type === "toolCall") ids.add(part.id);
}
continue;
}
if (message.role === "toolResult") ids.add(message.toolCallId);
}
return ids;
}