@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
157 lines (148 loc) • 7.75 kB
text/typescript
/**
* One non-streaming chat completion through this proxy's own /v1/chat/completions.
*
* The way opencodex makes a model call of its own: the request goes back through the router like
* any client's, so every provider the user has configured is reachable and none needs its own
* client here. The routed vision describer and the Codex role sizing both send through it.
*
* Destination: the unauthenticated loopback listener when one is enabled, otherwise the bind
* address (#4236), resolved by localInferenceDestination rather than composing 127.0.0.1 by hand.
* Admission: selfFetchAdmissionToken (env token, hardened service token file, first apiKeys entry;
* only a recognized one when the destination requires no admission), sent as x-opencodex-api-key
* and never Authorization, because an admission secret in a forwardable header is a forwarding
* hazard. Never the admin token.
*/
import type { OcxConfig } from "../types";
import { localInferenceDestination, selfFetchAdmissionToken } from "./local-destinations";
import { signalWithTimeout, cancelBodyOnAbort } from "./abort";
import { readBoundedResponseBytes } from "./bounded-body";
import { redactSecretString } from "./redact";
import { sidecarEnter } from "./sidecar-tracker";
import { internalCallCapability } from "./local-internal-call-capability";
import { registerAdvisorAdmissionPolicy, SIDECAR_ADMISSION_POLICY_HEADER, SIDECAR_INTERNAL_CAPABILITY_HEADER } from "../server/advisor-admission-scope";
import { configuredPort } from "../server/auth-cors";
import type { CapturedAdmissionPolicy } from "../types/admission-policy";
export type LocalChatConfig = Pick<OcxConfig, "port" | "hostname" | "apiKeys" | "unauthenticatedLoopbackListener">;
export interface LocalChatCompletionRequest {
readonly config: LocalChatConfig;
readonly body: Record<string, unknown>;
/** Names the caller in error text and logs, e.g. "routed describe". */
readonly label: string;
/** Log prefix and sidecar breadcrumb, e.g. "vision". */
readonly logTag: string;
readonly timeoutMs: number;
readonly maxResponseBytes: number;
/**
* Count raw bytes while reading and cancel the body at the bound. Unset keeps the routed
* describer's bound: the whole body is read, then its UTF-16 length is compared.
*/
readonly boundWhileStreaming?: boolean;
readonly headers?: Record<string, string>;
readonly admissionPolicy?: CapturedAdmissionPolicy;
readonly abortSignal?: AbortSignal;
/** Test seam; production always self-fetches the resolved local destination. */
readonly baseUrlOverride?: string;
}
export type LocalChatCompletionOutcome = { text: string; error?: string };
export function localChatCompletionDestination(config: Pick<OcxConfig, "port" | "hostname" | "unauthenticatedLoopbackListener">) {
// config.port can be 0 (ephemeral bind, tests) or stale after a live port override; the
// server records its ACTUAL bound port via setCorsOrigin at startup, so prefer that when
// config carries no positive port. configuredPort() is itself 0 when _corsOrigin has no
// explicit port (a default-port origin), so the literal default has to backstop it or the
// composed URL names port 0 and the self-fetch cannot connect.
const port = config.port && config.port > 0
? config.port
: Number(configuredPort()) || 10_100;
return localInferenceDestination(config, port);
}
export function localChatCompletionBaseUrl(
config: Pick<OcxConfig, "port" | "hostname" | "unauthenticatedLoopbackListener">,
): string {
return localChatCompletionDestination(config).origin;
}
export async function postLocalChatCompletion(request: LocalChatCompletionRequest): Promise<LocalChatCompletionOutcome> {
const { config, label, logTag } = request;
const headers: Record<string, string> = { "Content-Type": "application/json", ...request.headers };
const target = localChatCompletionDestination(config);
const admission = selfFetchAdmissionToken(config, target);
if (admission) headers["x-opencodex-api-key"] = admission;
// A bind that demands admission with no resolvable credential would return 401 with a body
// the caller reports as a failure; naming the cause once is the difference between "it is
// broken" and a fixable configuration note.
if (!admission && !request.baseUrlOverride && target.requiresAdmissionToken) {
console.warn(
`[${logTag}] ${label} has no opencodex data-plane credential for `
+ `${localChatCompletionBaseUrl(config)} — the self-fetch will be refused.`,
);
}
const linkedSignal = signalWithTimeout(request.timeoutMs, request.abortSignal);
const sidecarExit = sidecarEnter(logTag);
const t0 = Date.now();
let registration: ReturnType<typeof registerAdvisorAdmissionPolicy> | undefined;
try {
registration = registerAdvisorAdmissionPolicy(request.admissionPolicy, linkedSignal.signal);
headers[SIDECAR_ADMISSION_POLICY_HEADER] = registration.token;
headers[SIDECAR_INTERNAL_CAPABILITY_HEADER] = internalCallCapability();
const res = await fetch(`${request.baseUrlOverride ?? localChatCompletionBaseUrl(config)}/v1/chat/completions`, {
method: "POST",
headers,
body: JSON.stringify({ ...request.body, stream: false }),
signal: linkedSignal.signal,
redirect: "manual",
proxy: false,
});
const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
try {
let raw: string;
if (request.boundWhileStreaming) {
const read = await readBoundedResponseBytes(res, { maxBytes: request.maxResponseBytes, signal: linkedSignal.signal });
if (read.oversized) return { text: "", error: `${label} response exceeded byte bound` };
raw = new TextDecoder().decode(read.bytes);
} else {
raw = await res.text();
if (raw.length > request.maxResponseBytes) {
return { text: "", error: `${label} response exceeded byte bound` };
}
}
if (!res.ok) {
return { text: "", error: `${label} HTTP ${res.status}: ${redactSecretString(raw.slice(0, 200))}` };
}
let payload: unknown;
try { payload = JSON.parse(raw); } catch {
return { text: "", error: `${label} returned non-JSON` };
}
const content = extractChatContent(payload);
if (!content) return { text: "", error: `${label} returned no text` };
return { text: content };
} finally {
detachBodyGuard();
}
} catch (e) {
const kind = e instanceof Error && e.name === "TimeoutError" ? "timeout" : "connect_error";
console.warn(`[${logTag}] ${label} ${kind} (${Date.now() - t0}ms)`);
return { text: "", error: redactSecretString(e instanceof Error ? e.message : String(e)) };
} finally {
registration?.release();
sidecarExit();
linkedSignal.cleanup();
}
}
function extractChatContent(payload: unknown): string | undefined {
if (!payload || typeof payload !== "object") return undefined;
const choices = (payload as { choices?: unknown }).choices;
if (!Array.isArray(choices) || choices.length === 0) return undefined;
const message = (choices[0] as { message?: unknown })?.message;
if (!message || typeof message !== "object") return undefined;
const content = (message as { content?: unknown }).content;
if (typeof content === "string" && content.trim().length > 0) return content;
// Some adapters emit content parts; join text parts.
if (Array.isArray(content)) {
const joined = content
.map(part => (part && typeof part === "object" && typeof (part as { text?: unknown }).text === "string"
? (part as { text: string }).text
: ""))
.join("");
if (joined.trim().length > 0) return joined;
}
return undefined;
}