@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
207 lines (196 loc) • 9.32 kB
text/typescript
import type {
AdapterEvent,
OcxMessagePhase,
OcxProviderContinuationState,
OcxProviderOpaqueToolCallMetadata,
OcxReasoningReplayScopeRef,
OcxUsage,
} from "../types";
import {
adapterFailureFromMessage,
classifyError,
cyberPolicyErrorType,
CYBER_POLICY_ERROR_CODE,
isCyberPolicyCode,
type OcxErrorPayload,
} from "../lib/errors";
import { redactSecretString } from "../lib/redact";
import { formatRetryAfterAdvice } from "../lib/retry-delay";
import { usageDisplayTotalTokens } from "../usage/totals";
export function uuid(): string {
return crypto.randomUUID().replace(/-/g, "");
}
/** Test-only: bound the abandoned-owned-budget watchdog delay (null restores). */
export let ownedBudgetAbandonedMs = 10 * 60 * 1000;
const OWNED_BUDGET_ABANDONED_DEFAULT_MS = ownedBudgetAbandonedMs;
export function setOwnedBudgetAbandonedMsForTests(ms: number | null): void {
ownedBudgetAbandonedMs = ms ?? OWNED_BUDGET_ABANDONED_DEFAULT_MS;
}
function isRecord(value: unknown): value is Record<string, unknown> {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
export function responsesUsage(usage: OcxUsage | undefined): Record<string, unknown> {
// input_tokens_details / output_tokens_details are ALWAYS emitted (zero defaults):
// strict Responses clients deserialize them as required fields — grok-build's pinned
// async-openai fork (rev 95b52ebd, response_usage.rs) has non-Option InputTokenDetails/
// OutputTokenDetails, so omitting them turns a successful turn into a hard exit after
// response.completed ("missing field `input_tokens_details`", verified live 2026-07-23).
if (!usage) {
return {
input_tokens: 0,
output_tokens: 0,
total_tokens: 0,
input_tokens_details: { cached_tokens: 0 },
output_tokens_details: { reasoning_tokens: 0 },
};
}
// inputTokens is already inclusive of cache read/write (types.ts convention). Stateful
// providers may report an absolute active-context checkpoint separately from their
// per-attempt usage. Split that checkpoint into input + output without adding output twice.
const inputTokens = usage.contextTotalTokens !== undefined
? Math.max(0, usage.contextTotalTokens - usage.outputTokens)
: usage.inputTokens;
// openai/codex#41980 parity: unknown upstream usage fields (subscription metadata, future
// counters) pass through the rebuild. Normalized values stay authoritative for the known
// keys (they are derived from the same raw values, so this never disagrees with upstream).
const raw: Record<string, unknown> = usage.rawUsage ?? {};
// cache_write_tokens is a KNOWN key: it is emitted only from the validated normalized
// value below, never copied through raw (an unknown-shaped value must not leak into the
// normalized contract).
const rawInputDetails = isRecord(raw.input_tokens_details)
? Object.fromEntries(Object.entries(raw.input_tokens_details as Record<string, unknown>)
.filter(([key]) => key !== "cache_write_tokens"))
: {} as Record<string, unknown>;
const rawOutputDetails = isRecord(raw.output_tokens_details)
? raw.output_tokens_details as Record<string, unknown>
: {} as Record<string, unknown>;
const out: Record<string, unknown> = {
...Object.fromEntries(Object.entries(raw).filter(([key]) =>
key !== "input_tokens" && key !== "output_tokens" && key !== "total_tokens"
&& key !== "input_tokens_details" && key !== "output_tokens_details")),
input_tokens: inputTokens,
output_tokens: usage.outputTokens,
total_tokens: usage.contextTotalTokens !== undefined
? usage.contextTotalTokens
: usageDisplayTotalTokens(usage) ?? inputTokens + usage.outputTokens,
};
// cached_tokens carries cache READS only, matching OpenAI semantics, and is always present
// (zero default) for strict clients. Clamp to inputTokens so a provider's absolute
// checkpoint can never report more cache reads than input.
const inputDetails: Record<string, unknown> = {
...rawInputDetails,
cached_tokens: Math.min(usage.cachedInputTokens ?? 0, inputTokens),
};
if (usage.cacheCreationInputTokens !== undefined) {
const cacheRead = typeof inputDetails.cached_tokens === "number" ? inputDetails.cached_tokens : 0;
inputDetails.cache_write_tokens = Math.min(
usage.cacheCreationInputTokens,
Math.max(0, inputTokens - cacheRead),
);
}
out.input_tokens_details = inputDetails;
out.output_tokens_details = { ...rawOutputDetails, reasoning_tokens: usage.reasoningOutputTokens ?? 0 };
return out;
}
/**
* Whether assembled function-call arguments are usable JSON.
* An empty buffer is valid (no-arg tools send no deltas). Non-empty must parse —
* once fragments have been streamed to the client they cannot be repaired the way
* non-stream adapters degrade a bad payload to `{}`.
*/
export function toolCallArgumentsUsable(args: string): boolean {
if (args.length === 0) return true;
const trimmed = args.trim();
if (!trimmed) return false;
try {
JSON.parse(args);
return true;
} catch {
return false;
}
}
/**
* Whether an in-progress function-call argument buffer could still become valid JSON.
* The first non-whitespace byte must be one that can begin a JSON value. A stream that
* already lost its leading `{"` (observed from coding-agent CLIs as `code":"…}`) can only
* fail `toolCallArgumentsUsable` at completion, so streaming those fragments publishes
* bytes a failed item cannot take back — the same #765 rule that refuses completion.
*/
export function toolCallArgumentsCouldBeJson(args: string): boolean {
const first = args.trimStart().charAt(0);
if (first === "") return true;
return first === "{"
|| first === "["
|| first === "\""
|| first === "-"
|| (first >= "0" && first <= "9")
|| first === "t"
|| first === "f"
|| first === "n";
}
export function adapterFailureFromEvent(event: Extract<AdapterEvent, { type: "error" }>): { httpStatus: number; error: OcxErrorPayload } {
const message = redactSecretString(event.message);
if (event.status === undefined && event.errorType === undefined && event.code === undefined) {
return adapterFailureFromMessage(message);
}
const fallback = adapterFailureFromMessage(message);
let httpStatus = event.status ?? fallback.httpStatus;
const error = classifyError(httpStatus, event.errorType ?? fallback.error.type, message);
if (event.errorType !== undefined) error.type = event.errorType;
if (event.code !== undefined) error.code = event.code;
// Codex only parses a streamed retry delay for these canonical rate-limit codes.
// Preserve other typed verdicts (quota, auth, local send budgets) verbatim.
if (httpStatus === 429 && error.type === "rate_limit_error"
&& ["resource_exhausted", "rate_limit_exceeded", "slow_down"].includes(error.code ?? "")) {
// Without a usable delay, retain the original code and existing client behavior.
const advice = formatRetryAfterAdvice(message);
if (advice !== undefined) {
error.code = "rate_limit_exceeded";
error.message = advice;
}
}
// Codex maps cyber_policy on HTTP 400 (body) or mid-stream code; never leave it as 502.
if (isCyberPolicyCode(error.code) || isCyberPolicyCode(event.code)) {
error.code = CYBER_POLICY_ERROR_CODE;
error.type = cyberPolicyErrorType(event.errorType);
httpStatus = 400;
}
return { httpStatus, error };
}
/**
* Build the native `WebSearchAction::Search` payload from the queries that ran.
*
* Every action carries BOTH keys: `{ query, queries }`, where `query` is the first
* member. Empty → `{ query: "", queries: [""] }`.
*
* Carrying both is load-bearing in both directions. DeepSeek's native Responses parser
* makes `queries` a required field, and Console Go's upstream validator makes `query` a
* required field — so a replayed `web_search_call` carried in the history of every
* subsequent turn fails deserialization with `missing field 'queries'` (#930) or 400s
* with `missing required field 'query'` unless both keys are present. Carrying both keys
* in every case satisfies both strict parsers; the trade-off is that a multi-query batch
* loses the "<first> ..." ellipsis in codex-rs and shows the first query as the label.
*
* That trade is deliberate: a cosmetic label against a conversation that 400s on every
* subsequent turn. Do not restore the old batch-omits-`query` shape to win the ellipsis
* back — it reopens #3071.
*
* This fixes items created from here on. History recorded before it is repaired at the
* replay boundary by `backfillWebSearchQueries()` in the Responses adapter.
*/
export function webSearchAction(queries: string[]): Record<string, unknown> {
const first = queries[0] ?? "";
return { type: "search", query: first, queries: queries.length > 0 ? queries : [first] };
}
export interface OutputItem {
type: string;
id: string;
[key: string]: unknown;
}
/** Accumulates string fragments and their total byte length without concatenating. */
export interface StringChunks {
chunks: string[];
bytes: number;
}
export const emptyChunks = (): StringChunks => ({ chunks: [], bytes: 0 });
export const joinChunks = (sc: StringChunks): string => sc.chunks.join("");