@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
182 lines (161 loc) • 7.38 kB
text/typescript
import { getConfigDir } from "../../config/paths";
import { didRunDrainStartHooks, didRunOptionalShutdownHooks, registerAsyncOptionalShutdownHook } from "../../lib/optional-shutdown-hooks";
import type { AdapterEvent, OcxUsage } from "../../types";
import { buildStepCliArgs } from "./profiles";
/**
* How long a conversation's process survives without traffic.
*
* Long enough that a Codex thread's pauses between turns do not tear the conversation down, short
* enough that an abandoned thread does not leave a StepCode process running.
*/
export const STEP_CLI_IDLE_TIMEOUT_MS = 10 * 60_000;
import {
resolveStepCliBinaryPath,
stepCliProcessEnvironment,
StepSessionError,
type StepSessionDeps,
type StepSessionEvent,
} from "./session";
import {
StepSessionPool,
type StepConversationHost,
type StepConversationRef,
type StepConversationSession,
} from "./session-pool";
/**
* Process- and turn-lifetime state that outlives a request.
*
* `createStepCliAdapter` runs once per request, so anything that must survive a request boundary
* cannot live in its closure: a reverse request arriving during request N+1 would be routed to an
* instance that no longer exists and the conversation would silently restart. `devin/trajectory.ts`
* keeps its conversation map at module scope for the same reason.
*/
/**
* Per-request turn state, keyed by the process that owns it.
*
* `createStepCliAdapter` runs once per request, so nothing that has to survive a request boundary can
* live in its closure: a reverse request arriving during request N+1 would be routed to an instance
* that no longer exists, and the conversation would silently restart. `devin/trajectory.ts` keeps its
* conversation map at module scope for the same reason.
*/
export interface StepTurnRuntime {
ref: StepConversationRef;
pool: StepConversationHost;
emit: (event: AdapterEvent) => void;
settle: () => void;
emittedNames: Map<string, string>;
catalogKey: string;
queryId?: string;
}
export const turnRuntimes = new WeakMap<StepConversationSession, StepTurnRuntime>();
export const lastAssistantUsage = new WeakMap<StepConversationSession, OcxUsage>();
/** Query currently owned by each session, so an abandoned turn can interrupt exactly that one. */
export const lastQueryId = new WeakMap<StepConversationSession, string>();
/* ------------------------------------------------------------------------- *
* Turn runtime accessors.
*
* `events` and `adapter` go through these instead of touching the maps, so the storage shape can
* change without every caller changing with it — and so "who owns this session's turn" is answered in
* one place rather than by whoever happens to remember the variable name.
* ------------------------------------------------------------------------- */
/** Attach a turn to the session that owns it, replacing any turn left behind. */
export function beginTurn(session: StepConversationSession, turn: StepTurnRuntime): void {
lastAssistantUsage.delete(session);
turnRuntimes.set(session, turn);
}
/** The turn currently owning this session, if any. */
export function currentTurn(session: StepConversationSession): StepTurnRuntime | undefined {
return turnRuntimes.get(session);
}
/** Detach a session's turn. Returns true when one was actually attached. */
export function endTurn(session: StepConversationSession): boolean {
return turnRuntimes.delete(session);
}
/** Record the usage the CLI reported for this session's assistant turn. */
export function recordAssistantUsage(session: StepConversationSession, usage: OcxUsage): void {
lastAssistantUsage.set(session, usage);
}
/** The usage recorded for this session's assistant turn, if any. */
export function assistantUsage(session: StepConversationSession): OcxUsage | undefined {
return lastAssistantUsage.get(session);
}
/** Remember which query this session is running, so an abandoned turn interrupts exactly that one. */
export function rememberQuery(session: StepConversationSession, queryId: string): void {
lastQueryId.set(session, queryId);
const turn = currentTurn(session);
if (turn) turn.queryId = queryId;
}
/** The query this session is running, if any. */
export function currentQuery(session: StepConversationSession): string | undefined {
return lastQueryId.get(session);
}
/** Forget the session's query, e.g. once its input stream has been closed. */
export function forgetQuery(session: StepConversationSession): void {
lastQueryId.delete(session);
}
/** One pool per OpenCodex home, so two homes in one process never share a StepCode session. */
export const pools = new Map<string, StepSessionPool>();
const STEP_CLI_SHUTDOWN_KEY = "step-cli-sessions";
/** Close every owned process during proxy shutdown or an explicit registry clear. */
export async function clearStepCliSessions(deadlineMs?: number): Promise<void> {
const closed = await Promise.allSettled([...pools].map(async ([home, pool]) => {
await pool.closeAll(deadlineMs);
if (pools.get(home) === pool) pools.delete(home);
}));
const failure = closed.find(result => result.status === "rejected");
if (failure?.status === "rejected") throw failure.reason;
}
function forceStepCliShutdown(): void {
let failed = false;
for (const pool of pools.values()) {
try { pool.forceShutdown(); }
catch { failed = true; }
}
if (failed) throw new StepSessionError("StepCode emergency process cleanup failed.", "step_cli_cleanup_failed");
}
export function poolFor(
home: string,
deps: StepSessionDeps,
handlers: { onEvent(event: StepSessionEvent): void },
): StepSessionPool {
if (didRunDrainStartHooks() || didRunOptionalShutdownHooks()) throw new StepSessionError("StepCode cannot open sessions while the proxy is shutting down.");
const existing = pools.get(home);
if (existing) return existing;
registerAsyncOptionalShutdownHook(STEP_CLI_SHUTDOWN_KEY, clearStepCliSessions, forceStepCliShutdown);
const { env, cwd } = stepCliProcessEnvironment(home);
const pool = new StepSessionPool(
{
openCodexHome: home,
idleTimeoutMs: STEP_CLI_IDLE_TIMEOUT_MS,
buildOptions: () => ({
binary: resolveStepCliBinaryPath(deps.which),
args: buildStepCliArgs(undefined, undefined),
env,
cwd,
handshakeTimeoutMs: 30_000,
requestTimeoutMs: 120_000,
// StepCode's own tool window is 120s and answering later produces a `permission_denied`
// message inside the model's context, so the hold is bounded shorter and fails the turn.
reverseRequestHoldMs: 110_000,
idleTimeoutMs: STEP_CLI_IDLE_TIMEOUT_MS,
killGraceMs: 2_000,
}),
},
handlers,
deps,
);
pools.set(home, pool);
return pool;
}
/**
* A reverse request the CLI is waiting on this peer to answer.
*
* `permission.request` is allowed immediately because the approval already happened upstream of this
* adapter. A `sdk_tool.invoke` is deliberately NOT answered here: its result only exists once the
* client has executed the tool and sent its next request, and answering it is how that result reaches
* the model inside the query the model is already running.
*/
/**
* Exported for its regression tests: every reverse request must be ANSWERED, and the tests drive this
* exact function rather than a mirror of it.
*/