UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

94 lines (89 loc) • 4.08 kB
/** * Final request-log ownership for a native ingress that converts an inner Chat response. * * The inner Chat path keeps its own observation, attempt and usage accounting and its own * callback ordering. Its final-log requests are intercepted: the first one is recorded as the * physical attempt's settlement and nothing is written. The native handler, which alone knows * whether its conversion succeeded or the client went away, commits exactly once through the * ordinary writer. Later inner requests stay inert, so a delayed callback cannot add a row. */ import type { ResponsesTerminalStatus } from "../bridge"; import { addRequestLog, commitInterceptedFinalRequestLog, interceptFinalRequestLog, type RequestLogContext, type RequestLogEntry, } from "./request-log"; /** How long a known outer outcome waits for a missing inner settlement before cutting off. */ export const NATIVE_FINAL_LOG_FALLBACK_MS = 100; export const NATIVE_FINAL_LOG_CUTOFF_CODE = "observation_barrier_timeout"; export interface NativeFinalOutcome { status: number; terminalStatus?: ResponsesTerminalStatus; closeReason: NonNullable<RequestLogEntry["closeReason"]>; } export interface NativeFinalLog { /** True once the inner path requested its final log. */ innerSettled(): boolean; /** * Call once the outer outcome is known. Resolves true when the inner path has settled, or * false when the bounded fallback elapsed first. Never waits on an upstream cancellation. */ waitForInner(): Promise<boolean>; /** Write the single row. Returns false when a row was already committed. */ commit(outcome: NativeFinalOutcome): boolean; } export function createNativeFinalLog( requestId: string, start: number, logCtx: RequestLogContext, options: { fallbackMs?: number; addLog?: (entry: RequestLogEntry) => void } = {}, ): NativeFinalLog { const fallbackMs = options.fallbackMs ?? NATIVE_FINAL_LOG_FALLBACK_MS; let innerStatus: number | undefined; let wake: (() => void) | undefined; let waiting: Promise<boolean> | undefined; let committed = false; interceptFinalRequestLog(logCtx, status => { if (innerStatus !== undefined) return; innerStatus = status; // Resolved on a later microtask, so observations the inner producer makes later in the same // synchronous pass (a relay's completed-response hook, for example) land before the commit. wake?.(); }); return { innerSettled: () => innerStatus !== undefined, waitForInner() { waiting ??= innerStatus !== undefined ? Promise.resolve(true) : new Promise<boolean>(resolve => { const timer = setTimeout(() => { wake = undefined; resolve(innerStatus !== undefined); }, fallbackMs); wake = () => { clearTimeout(timer); wake = undefined; resolve(true); }; }); return waiting; }, commit(outcome) { if (committed) return false; committed = true; // Upstream evidence stays on the context so the final writer can classify it; the row // projection (src/usage/error-detail.ts) removes upstream-authored text before any writer. let { status, terminalStatus } = outcome; if (innerStatus === undefined) { // Cut off before the inner path settled: what it observed so far is not a complete // account. Drop it, so the row reads unreported and the terminal send settles as // unresolved rather than being priced from a partial count, and never report success. delete logCtx.usage; delete logCtx.usageLogInputTokens; if (logCtx.activeAttempt) delete logCtx.activeAttempt.usage; logCtx.errorCode = NATIVE_FINAL_LOG_CUTOFF_CODE; if (status < 400) { status = 502; terminalStatus = "failed"; } } commitInterceptedFinalRequestLog(requestId, start, logCtx, status, { ...(terminalStatus ? { terminalStatus } : {}), closeReason: status === 499 ? "client_cancel" : outcome.closeReason, }, innerStatus ?? status, options.addLog ?? addRequestLog); return true; }, }; }