UNPKG

@bitkyc08/opencodex

Version:

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

317 lines (286 loc) • 15.3 kB
import { createHash } from "node:crypto"; import { isAuthorizedProviderExecutedCall, type ProviderExecutedCallType } from "../server/responses-undeclared-tool-guard"; // Logical recency avoids clock adjustments and ties between messages in one millisecond. let activityOrder = 0; const MAX_PENDING_RESULTS = 1024; const MAX_RESULT_ID_LENGTH = 1024; const resultTypes: Readonly<Record<string, string>> = { function_call: "function_call_output", custom_tool_call: "custom_tool_call_output", local_shell_call: "function_call_output", shell_call: "shell_call_output", computer_call: "computer_call_output", apply_patch_call: "apply_patch_call_output", tool_search_call: "tool_search_output", mcp_approval_request: "mcp_approval_response", }; function record(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value); } function resultKey(type: string, id: string): string { return createHash("sha256").update(JSON.stringify([type, id])).digest("hex"); } function resultKeyOfItem(item: unknown): string | null { if (!record(item) || typeof item.type !== "string") return null; const id = item.type === "mcp_approval_response" ? item.approval_request_id : item.call_id; if (typeof id !== "string" || id.length > MAX_RESULT_ID_LENGTH) return null; return resultKey(item.type === "local_shell_call_output" ? "function_call_output" : item.type, id); } /** The hashed result keys an input returns, in the tracker's own encoding (content-free). */ export function resultKeysOf(input: unknown): string[] { if (!Array.isArray(input)) return []; return input.map(resultKeyOfItem).filter((key): key is string => key !== null); } /** Content-free activity owned by one admitted incoming Responses socket. */ export class CodexWebSocketActivity { lastUsed = ++activityOrder; private closingFlag = false; private turns = 0; private pendingResults = new Set<string>(); private returnedResults = new Set<string>(); // Hashed identities only; null marks a route-authorized provider-owned call. private argumentCalls = new Map<string, { type: string; result: string | null }>(); // Unknown/oversized identities cannot safely prove that client work finished. private untrackedResults = false; // Remote Link sockets observe their own activity; local sockets register nothing. private listeners: Array<() => void> = []; private acceptedListeners: Array<(input: unknown) => void> = []; private beginListeners: Array<(input: unknown) => void> = []; /** * Remote Link sockets only: a turn the shared handler never reports as accepted (notifyAccepted) * puts the results it settled back to pending when it finishes, so a refused or failed turn cannot * make unfinished client work look done. Local sockets keep settling at admission. */ restoreRefusedResults = false; private turnRecords = new Map<unknown, { seq: number; settled: string[]; accepted: boolean }>(); private turnSeq = 0; // Keys an unaccepted turn put back, with that turn's sequence; a key observed again as new work // loses its marker, so a late acceptance of an older turn never settles newer work. private restoredKeys = new Map<string, number>(); get closing(): boolean { return this.closingFlag; } set closing(value: boolean) { if (this.closingFlag === value) return; this.closingFlag = value; this.changed(); } get idle(): boolean { return !this.closing && this.turns === 0 && this.pendingResults.size === 0 && !this.untrackedResults; } /** A turn admitted on this socket has not finished, superseded cleanup included. */ get running(): boolean { return this.turns > 0; } /** How many admitted turns have not finished, superseded cleanup included. */ get runningTurns(): number { return this.turns; } /** The hashed keys of the results this socket is waiting for (content-free). */ pendingKeys(): string[] { return [...this.pendingResults]; } /** Identities overflowed or were ambiguous: completion of client work cannot be proved. */ get untracked(): boolean { return this.untrackedResults; } /** Read-only: whether this input returns at least one result the socket is waiting for. */ returnsPending(input: unknown): boolean { if (this.untrackedResults || !Array.isArray(input)) return false; for (const item of input) { const key = this.resultKeyOf(item); if (key !== null && this.pendingResults.has(key)) return true; } return false; } /** Called after any change that can move idle, running or the pending set. */ onChange(listener: () => void): () => void { this.listeners.push(listener); return () => { this.listeners = this.listeners.filter(candidate => candidate !== listener); }; } /** Called with a turn's input when it begins (Remote Link: the hold sequence a later acceptance may settle up to). */ onBegin(listener: (input: unknown) => void): () => void { this.beginListeners.push(listener); return () => { this.beginListeners = this.beginListeners.filter(candidate => candidate !== listener); }; } /** * Called with a turn's input once the shared handler got a successful response for it, after turn, * workflow and pipeline admission (notifyAccepted). Never for a warmup or any refusal. */ onAccepted(listener: (input: unknown) => void): () => void { this.acceptedListeners.push(listener); return () => { this.acceptedListeners = this.acceptedListeners.filter(candidate => candidate !== listener); }; } /** The shared handler's turn was accepted by every admission and the pipeline answered ok. */ notifyAccepted(input: unknown): void { const record = this.turnRecords.get(input); if (record) record.accepted = true; // Only sockets that restore refused results (Remote Link) reconcile, and only against turns that // began before the accepted one: newer turns own newer work, even when it reuses a call id. const returned = new Set(this.restoreRefusedResults && record ? resultKeysOf(input) : []); if (record && returned.size) { // An older turn still finishing (superseded, refused) must not put these results back... for (const other of this.turnRecords.values()) { if (other.seq < record.seq) other.settled = other.settled.filter(key => !returned.has(key)); } // ...and one an older turn already put back is settled again. let changed = false; for (const key of returned) { const by = this.restoredKeys.get(key); if (by !== undefined && by < record.seq && this.pendingResults.delete(key)) { this.restoredKeys.delete(key); // Not added to returnedResults: like beginTurn, a settled wait never suppresses a later // call that reuses its id, even from an upstream that omits response.created. changed = true; } } if (changed) this.changed(); } for (const listener of [...this.acceptedListeners]) { try { listener(input); } catch { /* an observer never breaks the socket's own bookkeeping */ } } } private changed(): void { for (const listener of [...this.listeners]) { try { listener(); } catch { /* an observer never breaks the socket's own bookkeeping */ } } } private resultKeyOf(item: unknown): string | null { return resultKeyOfItem(item); } touch(): void { this.lastUsed = ++activityOrder; } /** Each turn retains its own busy reference, including superseded async cleanup. */ beginTurn(input: unknown): () => void { this.turns += 1; this.touch(); const record = { seq: ++this.turnSeq, settled: this.settleResults(input), accepted: false }; if (this.restoreRefusedResults) this.turnRecords.set(input, record); for (const listener of [...this.beginListeners]) { try { listener(input); } catch { /* an observer never breaks the socket's own bookkeeping */ } } // Ordinary creates start a new response even when its upstream omits response.created. // Prior results settle old waits, but cannot suppress new calls reusing their IDs. this.returnedResults.clear(); this.argumentCalls.clear(); let finished = false; this.changed(); return () => { if (finished) return; finished = true; if (this.turnRecords.get(input) === record) this.turnRecords.delete(input); if (this.restoreRefusedResults && !record.accepted) this.restoreResults(record.settled, record.seq); this.turns -= 1; if (this.turns === 0) this.touch(); this.changed(); }; } /** Called only after admission or native control accepts the client's results. */ acceptResults(input: unknown): void { if (this.settleResults(input).length) this.changed(); } /** Settles returned results; the keys taken off the pending set. Notifies nobody. */ private settleResults(input: unknown): string[] { const settled: string[] = []; if (this.untrackedResults) return settled; if (Array.isArray(input)) { for (const item of input) { // Ordinary Codex shell results use function_call_output; native steering // also accepts its explicit local_shell_call_output continuation stub. const key = this.resultKeyOf(item); if (key !== null && this.pendingResults.delete(key)) { settled.push(key); this.restoredKeys.delete(key); if (this.returnedResults.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return []; } else this.returnedResults.add(key); } } } return settled; } /** A refused turn's results are owed again (restoreRefusedResults). */ private restoreResults(keys: readonly string[], seq: number): void { if (this.untrackedResults) return; for (const key of keys) { // Already pending means newer work under the same key: it keeps its own generation, untagged. if (this.pendingResults.has(key)) continue; this.returnedResults.delete(key); if (this.pendingResults.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; } this.pendingResults.add(key); this.restoredKeys.set(key, seq); } } /** Preserve tool waits even when the response terminal omits its output array. */ observePayload(payload: string, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void { if (this.untrackedResults) return; let frame: unknown; try { frame = JSON.parse(payload); } catch { return; } if (!record(frame)) return; // Native injection can return a result before the same terminal repeats its call. if (frame.type === "response.created") { this.returnedResults.clear(); this.argumentCalls.clear(); } if (frame.type === "response.output_item.added") this.rememberArgumentCall(frame.item, providerExecuted); if (frame.type === "response.function_call_arguments.done" || frame.type === "response.custom_tool_call_input.done") { const type = frame.type === "response.function_call_arguments.done" ? "function_call" : "custom_tool_call"; const call = typeof frame.item_id === "string" && frame.item_id.length <= MAX_RESULT_ID_LENGTH ? this.argumentCalls.get(resultKey("item", frame.item_id)) : undefined; if (!call || call.type !== type) this.protectUntracked(); else if (call.result !== null) this.observeResultKey(call.result); } if (frame.type === "response.output_item.done") this.observeOutput(frame.item, providerExecuted); if (["response.completed", "response.incomplete", "response.failed"].includes(String(frame.type)) && record(frame.response) && Array.isArray(frame.response.output)) { for (const item of frame.response.output) this.observeOutput(item, providerExecuted); } } private rememberArgumentCall(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void { if (!record(item) || (item.type !== "function_call" && item.type !== "custom_tool_call")) return; if (typeof item.id !== "string" || !item.id.length || item.id.length > MAX_RESULT_ID_LENGTH) return; const key = resultKey("item", item.id); const hosted = providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted); if (!hosted && (typeof item.call_id !== "string" || !item.call_id.length || item.call_id.length > MAX_RESULT_ID_LENGTH)) { if (this.argumentCalls.has(key)) this.protectUntracked(); return; } const result = hosted ? null : resultKey(resultTypes[item.type]!, item.call_id as string); const previous = this.argumentCalls.get(key); if (previous) { if (previous.type !== item.type || previous.result !== result) this.protectUntracked(); return; } if (this.argumentCalls.size >= MAX_PENDING_RESULTS) { this.protectUntracked(); return; } // An unfinished argument stream alone does not prove the client started work. this.argumentCalls.set(key, { type: item.type, result }); } private observeOutput(item: unknown, providerExecuted?: ReadonlySet<ProviderExecutedCallType>): void { if (this.untrackedResults) return; if (!record(item) || typeof item.type !== "string") return; // Hosted execution may publish both the call and its result in the output stream. // On a Remote Link socket only an accepted client turn returns a client result: provider-executed // calls never become pending, so an upstream output settling one would be ambiguous (design 5). if (!this.restoreRefusedResults) this.acceptResults([item]); if (!Object.hasOwn(resultTypes, item.type)) return; if (providerExecuted && isAuthorizedProviderExecutedCall(item, providerExecuted)) return; if (item.type === "tool_search_call" && item.execution !== "client") return; const id = item.type === "mcp_approval_request" ? item.id : item.type === "local_shell_call" || item.type === "tool_search_call" ? item.call_id ?? item.id : item.call_id; if (typeof id !== "string" || !id.length || id.length > MAX_RESULT_ID_LENGTH) { this.protectUntracked(); return; } this.observeResultKey(resultKey(resultTypes[item.type]!, id)); } private observeResultKey(key: string): void { // A call observed now is new work, whatever an older turn restored under the same key. this.restoredKeys.delete(key); // An in-flight turn may still restore an earlier call under this id. The key cannot tell the two // generations apart, so the socket's results become untracked: its close leaves an operator-only // hold rather than possibly forgetting either piece of owed work (Remote Link sockets only). if (this.restoreRefusedResults) { for (const record of this.turnRecords.values()) { if (record.settled.includes(key)) { this.protectUntracked(); return; } } } if (this.pendingResults.has(key) || this.returnedResults.has(key)) return; if (this.pendingResults.size >= MAX_PENDING_RESULTS) this.protectUntracked(); else { this.pendingResults.add(key); this.changed(); } } private protectUntracked(): void { this.untrackedResults = true; this.pendingResults.clear(); this.returnedResults.clear(); this.argumentCalls.clear(); this.changed(); } }