@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
163 lines (149 loc) • 6.24 kB
text/typescript
/**
* Process-local memo pairing a bridged hosted `web_search` cell with the destination's own
* call and the result the proxy executed for it (issue #4587).
*
* The web-search passthrough bridge (`src/web-search/passthrough-bridge.ts`) intercepts the
* destination's `function_call` named `web_search`, runs the search itself, and shows the
* caller a hosted `web_search_call` cell under a proxy-minted `ws_<uuid>` id. The caller
* stores that cell and replays it on every later turn. The destination, which never produced a
* `web_search_call` in its life, then sees an unknown item type carrying a query and sources
* but no result — so it usually just searches again.
*
* This memo is what lets the pre-dispatch rewrite in the Responses adapter put the destination's
* own `function_call` and `function_call_output` back in that item's place. It records exactly
* what `appendBridgeSearchTurn` would have written onto a continuation leg, so a replayed turn
* and a continued turn show the destination the same conversation.
*
* Scope. Entries are keyed by the exact conversation and serving identity in addition to the cell
* id. The cell id is a v4 UUID minted here, but possession of a client-visible id is not authority
* to recover result text under another provider, model, destination, or credential.
*
* Bounds and privacy. Result text is web content the caller already received, but it is still
* request-derived data: it lives in memory only, is never logged, serialized, or exported, and is
* bounded by entry count, total bytes, and TTL so a long-lived proxy cannot grow without limit.
*
* A miss is deliberately indistinguishable from "no entry": the caller leaves the replayed item
* alone. Neither re-running the search nor inventing a result is an acceptable recovery.
*/
import type { OcxReasoningReplayScopeRef } from "../types";
const MAX_ENTRIES = 64;
const MAX_TOTAL_BYTES = 512 * 1024;
const TTL_MS = 60 * 60 * 1000;
export interface BridgeSearchReplayEntry {
/** The destination's own call id, as it appeared on the intercepted item. */
callId: string;
/** The destination's own item id, replayed when the upstream supplied one. */
sourceItemId?: string;
/** The tool name the destination called, recorded rather than assumed. */
name: string;
/** The intercepted call's complete arguments text. */
argumentsText: string;
/** The tool result the bridge produced for that call. */
output: string;
}
interface StoredEntry {
entry: BridgeSearchReplayEntry;
bytes: number;
at: number;
}
const entries = new Map<string, StoredEntry>();
let totalBytes = 0;
let clockForTests: (() => number) | null = null;
const now = (): number => clockForTests?.() ?? Date.now();
/**
* Identify the exact conversation and upstream binding a bridged search belongs to.
*
* The serving route binds this holder only after provider, model, and physical credential
* selection. A missing conversation or binding fails closed: a cell id is client-visible and is
* not itself authority to recover another request's retained result.
*/
export function bridgeSearchReplayScope(scope: OcxReasoningReplayScopeRef | undefined): string | undefined {
const identity = scope?.current;
if (!scope?.clientPrincipalId || !scope.clientThreadId || !identity) return undefined;
return JSON.stringify([
scope.clientPrincipalId,
scope.clientThreadId,
identity.providerName,
identity.providerDestinationIdentity,
identity.adapterName,
identity.modelId,
identity.credentialIdentity,
]);
}
function keyFor(scope: string, cellItemId: string): string {
return scope + "\u0000" + cellItemId;
}
function drop(key: string, stored: StoredEntry): void {
entries.delete(key);
totalBytes -= stored.bytes;
}
function sweep(at: number): void {
for (const [key, stored] of entries) {
if (at - stored.at >= TTL_MS) drop(key, stored);
}
// Map iteration is insertion-ordered, so the oldest surviving entry is always the first one.
while (entries.size > MAX_ENTRIES || totalBytes > MAX_TOTAL_BYTES) {
const oldest = entries.entries().next();
if (oldest.done) {
totalBytes = 0;
return;
}
drop(oldest.value[0], oldest.value[1]);
}
}
/**
* Record one executed bridged search.
*
* An entry with no call id is not recorded: the restore would have to emit a `function_call`
* without one, which is not a valid item and could not be paired with its output anyway.
*/
export function rememberBridgeSearchReplay(
scope: string | undefined,
cellItemId: string,
entry: BridgeSearchReplayEntry,
): void {
if (!scope || cellItemId.length === 0 || entry.callId.length === 0) return;
const key = keyFor(scope, cellItemId);
const existing = entries.get(key);
if (existing) drop(key, existing);
const bytes = 2 * (
key.length
+ entry.callId.length
+ (entry.sourceItemId?.length ?? 0)
+ entry.name.length
+ entry.argumentsText.length
+ entry.output.length
);
// A single oversized result is refused outright rather than evicting the whole store for it.
if (bytes > MAX_TOTAL_BYTES) return;
entries.set(key, { entry: { ...entry }, bytes, at: now() });
totalBytes += bytes;
sweep(now());
}
/**
* Look up one recorded search without consuming it.
*
* The same cell is replayed on every subsequent turn of the conversation, so a consuming read
* would restore the pair once and then silently stop. Expiry stays absolute: a conversation that
* outlives the TTL degrades to today's behaviour (the hosted cell replays unchanged) rather than
* pinning entries open for as long as anyone keeps talking.
*/
export function peekBridgeSearchReplay(
scope: string | undefined,
cellItemId: string,
): BridgeSearchReplayEntry | undefined {
if (!scope || cellItemId.length === 0) return undefined;
const key = keyFor(scope, cellItemId);
const stored = entries.get(key);
if (!stored) return undefined;
if (now() - stored.at >= TTL_MS) {
drop(key, stored);
return undefined;
}
return stored.entry;
}
export function clearBridgeSearchReplayCacheForTests(clock?: (() => number) | null): void {
entries.clear();
totalBytes = 0;
clockForTests = clock ?? null;
}