UNPKG

@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
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 } } }; }