@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
201 lines (185 loc) • 8.14 kB
text/typescript
import { debugProviderDiagnostic } from "../../lib/debug";
import { isDebugEnabled } from "../../lib/debug-settings";
export function isRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
type InvalidToolCallReason =
| "tool_calls_not_array"
| "tool_call_not_object"
| "tool_call_id_invalid"
| "tool_call_function_not_object"
| "tool_call_function_name_invalid"
| "tool_call_function_name_blank"
| "tool_call_function_arguments_invalid";
export type InvalidToolCallDiagnostic = {
reason: InvalidToolCallReason;
callIndex?: number;
valueType: string;
};
type InvalidFieldShape =
| {
kind: "object";
knownKeys: string[];
knownFieldTypes: Record<string, string>;
hasUnknownKeys: boolean;
}
| {
kind: "array";
length: number;
};
const SAFE_TOOL_CALL_SHAPE_KEYS = [
"name",
"type",
"value",
"function",
"arguments",
"id",
"index",
] as const;
const SAFE_TOOL_CALL_SHAPE_KEY_SET = new Set<string>(SAFE_TOOL_CALL_SHAPE_KEYS);
function structuralValueType(value: unknown): string {
return value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
}
function invalidToolCallField(rawToolCalls: unknown, diagnostic: InvalidToolCallDiagnostic): unknown {
if (diagnostic.reason === "tool_calls_not_array") return rawToolCalls;
if (!Array.isArray(rawToolCalls) || diagnostic.callIndex === undefined) return undefined;
const rawToolCall = rawToolCalls[diagnostic.callIndex];
if (diagnostic.reason === "tool_call_not_object") return rawToolCall;
if (!isRecord(rawToolCall)) return undefined;
if (diagnostic.reason === "tool_call_function_not_object") return rawToolCall.function;
const rawFunction = rawToolCall.function;
switch (diagnostic.reason) {
case "tool_call_id_invalid":
return rawToolCall.id;
case "tool_call_function_name_invalid":
return isRecord(rawFunction) ? rawFunction.name : undefined;
case "tool_call_function_arguments_invalid":
return isRecord(rawFunction) ? rawFunction.arguments : undefined;
default:
return undefined;
}
}
function fingerprintInvalidField(value: unknown): InvalidFieldShape | undefined {
if (Array.isArray(value)) return { kind: "array", length: value.length };
if (!isRecord(value)) return undefined;
const knownKeys: string[] = [];
const knownFieldTypes: Record<string, string> = {};
for (const key of SAFE_TOOL_CALL_SHAPE_KEYS) {
if (!Object.hasOwn(value, key)) continue;
knownKeys.push(key);
knownFieldTypes[key] = structuralValueType(value[key]);
}
let hasUnknownKeys = false;
for (const key of Object.keys(value)) {
if (!SAFE_TOOL_CALL_SHAPE_KEY_SET.has(key)) {
hasUnknownKeys = true;
break;
}
}
return { kind: "object", knownKeys, knownFieldTypes, hasUnknownKeys };
}
/**
* Streamed string fields are absent when null or undefined (#1731): OpenAI-compatible
* streamers repeat already-sent `id`/`name`/`arguments` as null on continuation deltas.
* The accumulator and this diagnostic share this predicate so they cannot disagree about
* which delta was the invalid one.
*/
export function isInvalidStreamStringField(value: unknown): boolean {
return value != null && typeof value !== "string";
}
/**
* Explain only the rejected wire shape, never its values. This diagnostic exists so provider
* compatibility can be tightened from evidence without retaining tool arguments or credentials.
*/
export function diagnoseInvalidToolCalls(
rawToolCalls: unknown,
mode: "stream" | "response",
): InvalidToolCallDiagnostic | undefined {
if (!Array.isArray(rawToolCalls)) {
return { reason: "tool_calls_not_array", valueType: rawToolCalls === null ? "null" : typeof rawToolCalls };
}
for (let callIndex = 0; callIndex < rawToolCalls.length; callIndex++) {
const rawToolCall = rawToolCalls[callIndex];
if (!isRecord(rawToolCall)) {
return {
reason: "tool_call_not_object",
callIndex,
valueType: rawToolCall === null ? "null" : Array.isArray(rawToolCall) ? "array" : typeof rawToolCall,
};
}
if (mode === "stream") {
// The streamed path validates the pieces it is about to store (#1531): a present
// `function` must be a record, and a present `name`/`arguments`/`id` must be a string.
// Blank names are caught later at flush, not here, so they are not diagnosed on this
// branch. Describe exactly that boundary rather than tightening compatibility in a
// diagnostic change.
// #1731: "present" means the same thing here as in the accumulator — null and undefined
// are both absent, because some OpenAI-compatible streamers repeat already-sent fields
// as null on continuation deltas. A separate predicate here would diagnose accepted
// padding as the failure and point compatibility work at the wrong delta.
const streamFunction = (rawToolCall as { function?: unknown }).function;
if (streamFunction !== undefined && streamFunction !== null) {
if (!isRecord(streamFunction)) {
return {
reason: "tool_call_function_not_object",
callIndex,
valueType: Array.isArray(streamFunction) ? "array" : typeof streamFunction,
};
}
if (isInvalidStreamStringField(streamFunction.name)) {
return { reason: "tool_call_function_name_invalid", callIndex, valueType: typeof streamFunction.name };
}
if (isInvalidStreamStringField(streamFunction.arguments)) {
return { reason: "tool_call_function_arguments_invalid", callIndex, valueType: typeof streamFunction.arguments };
}
}
if (isInvalidStreamStringField(rawToolCall.id)) {
return { reason: "tool_call_id_invalid", callIndex, valueType: typeof rawToolCall.id };
}
continue;
}
// Precedence must mirror the buffered validator below, or a payload with more than one
// problem is reported under the wrong reason and sends compatibility work after the wrong
// shape. That validator checks the `function` container first (`!isRecord(rawToolCall) ||
// !isRecord(rawToolCall.function)`), then id/name/arguments types together, and only then
// the blank name.
if (!isRecord(rawToolCall.function)) {
return {
reason: "tool_call_function_not_object",
callIndex,
valueType: rawToolCall.function === null ? "null" : Array.isArray(rawToolCall.function) ? "array" : typeof rawToolCall.function,
};
}
if (typeof rawToolCall.id !== "string") {
return { reason: "tool_call_id_invalid", callIndex, valueType: typeof rawToolCall.id };
}
if (typeof rawToolCall.function.name !== "string") {
return { reason: "tool_call_function_name_invalid", callIndex, valueType: typeof rawToolCall.function.name };
}
if (typeof rawToolCall.function.arguments !== "string") {
return { reason: "tool_call_function_arguments_invalid", callIndex, valueType: typeof rawToolCall.function.arguments };
}
// Last, matching the validator: #1531 also rejects a blank or whitespace-only name here,
// because such a call cannot select a dispatch target. Reporting it as `name_invalid`
// would claim a type problem for a correctly-typed value, so it gets its own code.
if (rawToolCall.function.name.trim().length === 0) {
return { reason: "tool_call_function_name_blank", callIndex, valueType: "string" };
}
}
return undefined;
}
export function logInvalidToolCalls(
mode: "stream" | "response",
rawToolCalls: unknown,
diagnosticOverride?: InvalidToolCallDiagnostic,
): void {
if (!isDebugEnabled()) return;
const diagnostic = diagnosticOverride ?? diagnoseInvalidToolCalls(rawToolCalls, mode);
if (!diagnostic) return;
const fieldShape = fingerprintInvalidField(invalidToolCallField(rawToolCalls, diagnostic));
debugProviderDiagnostic("openai-chat", "invalid-tool-calls", {
mode,
...diagnostic,
...(fieldShape ? { fieldShape } : {}),
});
}