@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
190 lines (186 loc) • 12.5 kB
text/typescript
import { createHash } from "node:crypto";
import type { OcxParsedRequest, OcxProviderConfig } from "../types";
import { readBoundedResponseBody } from "../lib/bounded-body";
import { ProviderOutboundSendCancelledError, providerOutboundGet, providerOutboundPost } from "../lib/provider-outbound";
import { githubCopilotHttpError, resolveCopilotApiBaseUrl } from "../oauth/github-copilot";
import { resolveGithubCopilotTransport } from "./github-copilot-transport";
import { waitForProviderRequestSlot, releaseProviderRequestSlot } from "./request-pacing";
export interface CopilotModel {
id: string;
model_picker_enabled?: boolean;
supported_endpoints?: string[];
[key: string]: unknown;
}
const catalogs = new Map<string, { expires: number; models: CopilotModel[] }>();
const MAX_MODELS = 512;
const MAX_RESPONSE_BYTES = 1_048_576;
export class CopilotAutoHttpError extends Error {
/** Preserve only the upstream status and bounded retry delay; never retain response bodies. */
constructor(readonly status: number, readonly retryAfter?: string) {
super(githubCopilotHttpError("Auto negotiation", status).message);
}
}
/** Reject array/scalar payloads before interpreting negotiation objects. */
function record(value: unknown): Record<string, unknown> | undefined {
return value !== null && typeof value === "object" && !Array.isArray(value)
? value as Record<string, unknown> : undefined;
}
/** Accept a bounded, homogeneous list so malformed pools cannot grant routing eligibility. */
function strings(value: unknown): string[] {
return Array.isArray(value) && value.length <= MAX_MODELS
&& value.every(/** Require every pool entry to be a bounded nonempty string before it can authorize model selection. */
v => typeof v === "string" && v.length > 0 && v.length <= 256)
? value as string[] : [];
}
/** Isolate discovery caches by endpoint and credential without storing plaintext cache keys. */
function authority(provider: OcxProviderConfig): string {
return createHash("sha256").update(JSON.stringify([provider.baseUrl, provider.apiKey])).digest("hex");
}
/** Make one paced, origin-fenced negotiation send with bounded decoding and secret-safe errors. */
async function requestJson(provider: OcxProviderConfig, path: string, signal?: AbortSignal, body?: unknown,
sessionToken?: string, beforeSend?: () => boolean, concurrency = true): Promise<Record<string, unknown>> {
const boundedSignal = signal ? AbortSignal.any([signal, AbortSignal.timeout(8_000)]) : AbortSignal.timeout(8_000);
boundedSignal.throwIfAborted();
const headers = new Headers(provider.headers);
headers.set("Authorization", `Bearer ${provider.apiKey}`);
headers.set("X-GitHub-Api-Version", "2026-08-01");
headers.set("Content-Type", "application/json");
headers.delete("Copilot-Session-Token");
if (sessionToken) headers.set("Copilot-Session-Token", sessionToken);
const url = `${provider.baseUrl}${path}`;
// Queued-dispatch rebuilding can already own a provider concurrency lease; that
// caller opts out of taking a second lease while retaining interval pacing.
const slot = await waitForProviderRequestSlot("github-copilot", provider, "auto", boundedSignal, { concurrency });
try {
const init = { headers, signal: boundedSignal };
const response = body === undefined
? await providerOutboundGet("github-copilot", provider, url, init, { beforeSend })
: await providerOutboundPost("github-copilot", provider, url, { ...init, body: JSON.stringify(body) }, { beforeSend });
// Status-only failures: session endpoints can echo secret material in their bodies.
if (!response.ok) {
void response.body?.cancel().catch(/** Ignore cleanup failures after discarding a refusal body that may contain reflected credentials. */
() => undefined);
const retry = response.headers.get("retry-after");
throw new CopilotAutoHttpError(response.status, retry && /^\d{1,4}$/.test(retry)
? String(Math.max(1, Math.min(3600, Number(retry)))) : undefined);
}
const bounded = await readBoundedResponseBody(response, { maxBytes: MAX_RESPONSE_BYTES,
signal: boundedSignal, totalTimeoutMs: 8_000, fatalUtf8: true });
if (bounded.truncated) throw new Error("GitHub Copilot Auto negotiation returned an incomplete response");
let value: unknown;
try { value = JSON.parse(bounded.text); } catch { /* never include raw bodies */ }
const payload = record(value);
if (!payload) throw new Error("GitHub Copilot Auto negotiation returned invalid JSON");
return payload;
} catch (error) {
if (error instanceof CopilotAutoHttpError || error instanceof ProviderOutboundSendCancelledError) throw error;
// Transport/decoder exception messages may contain reflected header values.
throw new Error(boundedSignal.aborted ? "GitHub Copilot Auto negotiation cancelled"
: "GitHub Copilot Auto negotiation transport failed");
} finally { releaseProviderRequestSlot(slot); }
}
/** Detect Auto-only permission only when every row explicitly denies named selection. */
export function copilotRequiresAuto(_provider: OcxProviderConfig, models: CopilotModel[]): boolean {
return models.length > 0 && models.every(/** Missing or malformed metadata cannot establish an account-wide picker denial. */
model => model.model_picker_enabled === false);
}
/** Retain legacy rows with unknown permissions; only an explicit denial removes a named picker row. */
export function copilotPickerModels(provider: OcxProviderConfig, models: CopilotModel[]): CopilotModel[] {
if (copilotRequiresAuto(provider, models)) return [{ id: "auto" }];
return models.filter(/** Preserve named selection unless the provider explicitly marks the row unavailable. */
model => model.model_picker_enabled !== false);
}
/** Read the credential-bound catalog; callers may disable caching or reuse an existing lease. */
export async function fetchCopilotAutoModels(provider: OcxProviderConfig, signal?: AbortSignal,
beforeSend?: () => boolean, cacheTtlMs = 60_000, concurrency = true): Promise<CopilotModel[]> {
const key = authority(provider);
const cached = catalogs.get(key);
if (cacheTtlMs > 0 && cached && cached.expires > Date.now()) return cached.models;
const payload = await requestJson(provider, "/models", signal, undefined, undefined, beforeSend, concurrency);
if (!Array.isArray(payload.data) || payload.data.length > MAX_MODELS)
throw new Error("GitHub Copilot model discovery returned an invalid catalog");
const models = payload.data.flatMap(/** Discard malformed catalog rows while retaining metadata for bounded model identifiers. */
value => {
const row = record(value);
if (!row || typeof row.id !== "string" || !row.id || row.id.length > 256) return [];
return [{ ...row, id: row.id } as CopilotModel];
});
if (cacheTtlMs > 0) {
if (!catalogs.has(key) && catalogs.size >= 32) catalogs.delete(catalogs.keys().next().value!);
catalogs.set(key, { expires: Date.now() + Math.min(cacheTtlMs, 60_000), models });
}
return models;
}
/** Reset discovery state between isolated account/permission regression cases. */
export function clearCopilotAutoModelsForTests(): void { catalogs.clear(); }
/** Resolve before adapter construction: the server can choose either wire on every turn. */
export async function resolveCopilotAuto(provider: OcxProviderConfig, requestedModel: string,
parsed: OcxParsedRequest, signal?: AbortSignal, beforeSend?: () => boolean, concurrency = true): Promise<{
provider: OcxProviderConfig; modelId: string; auto: boolean; expiresAt?: number;
}> {
const transport = resolveGithubCopilotTransport(provider, provider.authMode === "oauth"
? resolveCopilotApiBaseUrl(provider.baseUrl) : undefined);
// Never inherit a session token from a previous account or persist it in config.
const cleanHeaders = new Headers(transport.headers);
cleanHeaders.delete("Copilot-Session-Token");
transport.headers = Object.fromEntries(cleanHeaders);
let models: CopilotModel[];
try { models = await fetchCopilotAutoModels(transport, signal, beforeSend, 60_000, concurrency); }
catch (error) {
if (signal?.aborted) throw error;
// A manual account switch makes `beforeSend` return false, which cancels this
// control-plane send. That is not a client abort: fall back to the requested model
// so the dispatch path revalidates the selection and rebuilds on the new account.
if (error instanceof ProviderOutboundSendCancelledError) {
return { provider: transport, modelId: requestedModel, auto: false };
}
// Permission discovery is additive for legacy paid configurations. A temporary
// discovery outage must not turn a previously usable named route into a refusal.
return { provider: transport, modelId: requestedModel, auto: false };
}
if (!copilotRequiresAuto(provider, models))
return { provider: transport, modelId: requestedModel, auto: false };
// The same authority fence guards the later control-plane sends: a manual switch that
// lands during the session or intent step falls back too, so dispatch rebuilds on the
// new account instead of failing the whole negotiation. A client abort still rejects.
const fallBackOnSwitch = (error: unknown) => {
if (!signal?.aborted && error instanceof ProviderOutboundSendCancelledError)
return { provider: transport, modelId: requestedModel, auto: false } as const;
throw error;
};
let session: Awaited<ReturnType<typeof requestJson>>;
try {
session = await requestJson(transport, "/models/session", signal,
{ auto_mode: { model_hints: ["auto"] } }, undefined, beforeSend, concurrency);
} catch (error) { return fallBackOnSwitch(error); }
const pool = strings(session.available_models);
if (typeof session.session_token !== "string" || !session.session_token || session.session_token.length > 32_768 || !/^[\x21-\x7e]+$/.test(session.session_token) || !pool.length)
throw new Error("GitHub Copilot Auto session omitted its routing credentials");
if (session.expires_at !== undefined && (typeof session.expires_at !== "number" || !Number.isFinite(session.expires_at)))
throw new Error("GitHub Copilot Auto session returned an invalid expiry");
const expiresAt = typeof session.expires_at === "number" && Number.isFinite(session.expires_at)
? session.expires_at * 1000 : Date.now() + 60_000;
if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() + 1000) throw new Error("GitHub Copilot Auto session is already expired");
const lastUser = [...parsed.context.messages].reverse().find(/** Find the newest user turn as the intent-routing source instead of replaying earlier conversation text. */
message => message.role === "user");
const prompt = lastUser?.role === "user"
? typeof lastUser.content === "string" ? lastUser.content : lastUser.content.flatMap(/** Extract text parts for intent negotiation without forwarding image or other multimodal payloads. */
part => part.type === "text" ? [part.text] : []).join("\n")
: "";
let intent: Awaited<ReturnType<typeof requestJson>>;
try {
intent = await requestJson(transport, "/models/session/intent", signal,
{ prompt: prompt.slice(0, 32_768), available_models: pool }, session.session_token, beforeSend, concurrency);
} catch (error) { return fallBackOnSwitch(error); }
const modelId = strings(intent.candidate_models).find(/** Choose the first server-ranked candidate that belongs to this credential-bound session pool. */
candidate => pool.includes(candidate));
if (!modelId) throw new Error("GitHub Copilot Auto intent returned no eligible model");
const endpoints = strings(models.find(/** Read endpoint capabilities for the selected model before choosing its inference adapter. */
model => model.id === modelId)?.supported_endpoints);
const adapter = endpoints.includes("/responses") ? "openai-responses"
: endpoints.includes("/chat/completions") ? "openai-chat" : undefined;
if (!adapter) throw new Error("GitHub Copilot Auto selected a model with no supported inference endpoint");
return { auto: true, modelId, expiresAt: Math.min(expiresAt, Date.now() + 60_000), provider: { ...transport, adapter,
...(adapter === "openai-responses" ? { responsesPath: "/responses" } : { chatCompletionsPath: "/chat/completions" }),
headers: { ...transport.headers, "X-GitHub-Api-Version": "2026-08-01", "Copilot-Session-Token": session.session_token } } };
}