@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
135 lines (125 loc) • 6.42 kB
text/typescript
import { collectResponsesToolGroups } from "./tool-groups";
import { isSchemaValidResponsesToolName, wireToolInnerName } from "./tool-name-aliases";
import { CODE_MODE_HELPER_WIRE_NAMES, dottedToolName, namespacedToolName } from "../types";
/**
* The one invented namespace this proxy is known to have emitted. Routed providers flatten a
* namespaced call as `ns.name`, and a provider that invents the grouping picks `default`; #3402,
* #4176 and #4412 all repaired that spelling on the way IN, each on its own path.
*
* This is deliberately one literal prefix rather than a rule. "Strip everything before the first
* dot" would silently rewrite a legitimate tool name that happens to contain a dot in some other
* provider's vocabulary, and a replayed history item is the worst possible place to guess: it names
* a call that already happened.
*/
const LEGACY_INVENTED_NAMESPACE_PREFIX = "default.";
/** Item types whose `name` the upstream validates against the tool-name pattern. */
const NAMED_CALL_ITEM_TYPES = new Set(["function_call", "custom_tool_call"]);
function isPlainObject(value: unknown): value is Record<string, unknown> {
return !!value && typeof value === "object" && !Array.isArray(value);
}
type DeclarationView = {
/** Wire spellings the caller's own catalog declares, including flattened namespace forms. */
readonly spellings: ReadonlySet<string>;
/** How many declared identities answer to a given inner name. */
readonly ownersByInnerName: ReadonlyMap<string, number>;
};
/**
* Read the request's own catalog. Namespace children contribute their inner name and both
* flattened spellings, which is what makes a declared `default` namespace distinguishable from an
* invented one.
*/
function readDeclarations(body: unknown): DeclarationView {
const spellings = new Set<string>();
const owners = new Map<string, number>();
const identities = new Map<string, Set<string>>();
const claim = (innerName: string, identity: string): void => {
const seen = identities.get(innerName);
if (seen === undefined) identities.set(innerName, new Set([identity]));
else seen.add(identity);
};
for (const group of collectResponsesToolGroups(body)) {
for (const spec of group) {
if (!isPlainObject(spec)) continue;
if (spec.type === "namespace" && Array.isArray(spec.tools)) {
const namespace = typeof spec.name === "string" ? spec.name : undefined;
if (namespace === undefined) continue;
for (const child of spec.tools) {
const inner = wireToolInnerName(child);
if (!inner) continue;
spellings.add(namespacedToolName(namespace, inner));
spellings.add(dottedToolName(namespace, inner));
claim(inner, JSON.stringify([namespace, inner]));
}
continue;
}
const name = wireToolInnerName(spec);
if (!name) continue;
spellings.add(name);
claim(name, JSON.stringify([null, name]));
}
}
for (const [inner, owning] of identities) owners.set(inner, owning.size);
return { spellings, ownersByInnerName: owners };
}
/**
* Canonical name a legacy dotted alias should be replayed under, or undefined to leave it alone.
*
* Fail-closed in both directions that matter. A dotted spelling the caller's catalog actually
* declares is a real tool identity, so it is never stripped — rewriting it would change which tool
* the history says was called. A suffix claimed by two declared identities is ambiguous and is
* left as it is. Only two things resolve: a suffix that names exactly one declared tool, and the
* bounded set of code-mode helper spellings, which a code-mode catalog never declares because they
* exist only as nested `tools.*` helpers inside `exec`.
*/
function repairedCallName(name: string, declarations: DeclarationView): string | undefined {
if (isSchemaValidResponsesToolName(name)) return undefined;
if (!name.startsWith(LEGACY_INVENTED_NAMESPACE_PREFIX)) return undefined;
if (declarations.spellings.has(name)) return undefined;
const suffix = name.slice(LEGACY_INVENTED_NAMESPACE_PREFIX.length);
if (!isSchemaValidResponsesToolName(suffix)) return undefined;
const owners = declarations.ownersByInnerName.get(suffix);
if (owners === 1) return suffix;
if (owners !== undefined) return undefined;
return CODE_MODE_HELPER_WIRE_NAMES.has(suffix) ? suffix : undefined;
}
function repairedItem(item: unknown, declarations: DeclarationView): unknown {
if (!isPlainObject(item)) return item;
if (typeof item.type !== "string" || !NAMED_CALL_ITEM_TYPES.has(item.type)) return item;
// An item carrying an explicit namespace is a namespaced identity whose `name` is the inner
// name; it is not the flattened shape this repairs, and its own field is the authority.
if (item.namespace !== undefined) return item;
if (typeof item.name !== "string") return item;
const repaired = repairedCallName(item.name, declarations);
return repaired === undefined ? item : { ...item, name: repaired };
}
/**
* Make an already-damaged conversation replayable.
*
* A `function_call` whose name violates `^[a-zA-Z0-9_-]+$` is not a one-turn failure: Codex stores
* the item, and the upstream then refuses EVERY later request that replays it
* (`Invalid 'input[N].name': ...`) — including the automatic compaction a long task or a side chat
* triggers. The emit-side fix stops new items from being created; without this the conversations
* that already contain one stay permanently unusable, which is the part of #5095 that actually
* hurts.
*
* Only replayed input items are touched. The caller's tool catalog is never rewritten, and a body
* with nothing to repair is returned by reference.
*/
export function repairLegacyDottedToolCallNames(body: unknown): unknown {
if (!isPlainObject(body) || !Array.isArray(body.input)) return body;
if (!body.input.some(item =>
isPlainObject(item)
&& typeof item.type === "string"
&& NAMED_CALL_ITEM_TYPES.has(item.type)
&& typeof item.name === "string"
&& item.name.startsWith(LEGACY_INVENTED_NAMESPACE_PREFIX)
)) return body;
const declarations = readDeclarations(body);
let changed = false;
const input = body.input.map(item => {
const repaired = repairedItem(item, declarations);
if (repaired !== item) changed = true;
return repaired;
});
return changed ? { ...body, input } : body;
}