@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
140 lines (128 loc) • 5.6 kB
text/typescript
import { linkRouteAllowed } from "./routes";
/** A link with no relayed model turn for this long reads as idle (D5). */
export const DEFAULT_IDLE_AFTER_MS = 600_000;
const DELIVERY_WINDOW_MS = 120_000;
export const LINK_DELIVERY_SAMPLE_LIMIT = 5;
export const LINK_DELIVERY_DEGRADED_THRESHOLD = 3;
export type LinkHttpDeliveryOutcome = "observed" | "upstream_failure" | "client_cancelled";
export interface LinkActivitySnapshot {
inFlight: number;
lastDataEndAt: number | null;
observedSince: number;
httpDelivery?: {
generation: string;
recentAuthentication: boolean;
recentSettled: number;
recentInterruptions: number;
recentCancellations: number;
};
}
/** One Remote Link WebSocket in the book: it counts in flight while busy (design T4 section 5). */
export interface LinkSocketActivity {
busy(value: boolean): void;
end(): void;
}
export interface LinkActivity {
/**
* Start one relayed model request. null = a legacy key admission without a relay session; it counts against every
* link. The returned end is idempotent and stamps lastDataEndAt.
*/
begin(linkId: string | null): () => void;
/** One model HTTP request admitted on an authenticated relay session for this generation. */
beginHttpDelivery(linkId: string, generation: string): (outcome: LinkHttpDeliveryOutcome) => void;
/** A link WebSocket; busy while a turn runs or client work is pending. Idempotent end. */
beginSocket(linkId: string): LinkSocketActivity;
snapshot(linkId: string, now: number): LinkActivitySnapshot;
}
/** Model traffic only: a POST the data-plane table admits, except token counting. */
export function linkActivityCounts(url: URL, req: Request): boolean {
return req.method === "POST" && url.pathname !== "/v1/messages/count_tokens" && linkRouteAllowed(url, req);
}
export function isLinkIdle(snapshot: LinkActivitySnapshot, now: number, idleAfterMs = DEFAULT_IDLE_AFTER_MS): boolean {
return snapshot.inFlight === 0 && now - (snapshot.lastDataEndAt ?? snapshot.observedSince) >= idleAfterMs;
}
interface HttpDelivery {
generation: string;
lastAdmissionAt: number;
settled: Array<{ at: number; outcome: LinkHttpDeliveryOutcome }>;
}
interface ActivityEntry { inFlight: number; lastDataEndAt: number | null; httpDelivery?: HttpDelivery }
/** In memory, no timers. One small entry per link id that ever relayed; links are bounded by links.json. */
/** held: durable link WebSocket holds (src/link/ws-activity-holds.ts), counted as in flight. */
export function createLinkActivity(deps: { now?: () => number; held?: (linkId: string) => number } = {}): LinkActivity {
const now = deps.now ?? Date.now;
const observedSince = now();
const perLink = new Map<string, ActivityEntry>();
const legacy: ActivityEntry = { inFlight: 0, lastDataEndAt: null };
const entryFor = (linkId: string): ActivityEntry => {
let entry = perLink.get(linkId);
if (!entry) { entry = { inFlight: 0, lastDataEndAt: null }; perLink.set(linkId, entry); }
return entry;
};
return {
begin(linkId) {
const entry = linkId === null ? legacy : entryFor(linkId);
entry.inFlight += 1;
let ended = false;
return () => {
if (ended) return;
ended = true;
entry.inFlight -= 1;
entry.lastDataEndAt = now();
};
},
beginHttpDelivery(linkId, generation) {
const entry = entryFor(linkId);
const admittedAt = now();
if (entry.httpDelivery?.generation !== generation) entry.httpDelivery = { generation, lastAdmissionAt: admittedAt, settled: [] };
const delivery = entry.httpDelivery;
delivery.lastAdmissionAt = admittedAt;
let ended = false;
return outcome => {
if (ended || entry.httpDelivery !== delivery) return;
ended = true;
delivery.settled.push({ at: now(), outcome });
if (delivery.settled.length > LINK_DELIVERY_SAMPLE_LIMIT) delivery.settled.shift();
};
},
beginSocket(linkId) {
const entry = entryFor(linkId);
let counted = false;
let ended = false;
const set = (value: boolean): void => {
if (ended || value === counted) return;
counted = value;
entry.inFlight += value ? 1 : -1;
if (!value) entry.lastDataEndAt = now();
};
return {
busy: set,
end() { set(false); ended = true; },
};
},
snapshot(linkId, at) {
const entry = perLink.get(linkId);
const ends = [entry?.lastDataEndAt ?? null, legacy.lastDataEndAt].filter((value): value is number => value !== null);
let held = 0;
try { held = deps.held?.(linkId) ?? 0; } catch { held = 1; }
const snapshot: LinkActivitySnapshot = {
inFlight: (entry?.inFlight ?? 0) + legacy.inFlight + held,
lastDataEndAt: ends.length ? Math.max(...ends) : null,
observedSince,
};
const delivery = entry?.httpDelivery;
if (delivery) {
const isRecent = (time: number): boolean => at >= time && at - time < DELIVERY_WINDOW_MS;
const recent = delivery.settled.filter(sample => isRecent(sample.at));
snapshot.httpDelivery = {
generation: delivery.generation,
recentAuthentication: isRecent(delivery.lastAdmissionAt) || recent.length > 0,
recentSettled: recent.length,
recentInterruptions: recent.filter(sample => sample.outcome === "upstream_failure").length,
recentCancellations: recent.filter(sample => sample.outcome === "client_cancelled").length,
};
}
return snapshot;
},
};
}