@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
364 lines (348 loc) • 17 kB
text/typescript
import { resolveAnthropicHelperSnapshot, fetchAnthropicHelper, anthropicHelperMessagesUrl } from "../sidecar/anthropic-binding";
import { isAnthropicInstanceId } from "../providers/anthropic-instance-id";
import type { OAuthAccessSnapshot } from "../oauth";
import type { OcxConfig, OcxProviderConfig } from "../types";
import { publicOAuthAuthenticationErrorMessage } from "../oauth";
import { getAnthropicSidecarAccessToken } from "../oauth/anthropic-routing";
import { ANTHROPIC_OAUTH_BETA, CLAUDE_CODE_SYSTEM_INSTRUCTION } from "../oauth/anthropic";
import { CLAUDE_CLI_USER_AGENT } from "../providers/claude-cli-identity";
import { sidecarThinkingOff } from "../adapters/anthropic-model-contract";
import { CLAUDE_CODE_HEADERS, claudeCodeSessionId } from "../adapters/client-fingerprint";
import { signalWithTimeout, cancelBodyOnAbort } from "../lib/abort";
import { sidecarEnter } from "../lib/sidecar-tracker";
import { applyUpstreamRecoveryInit, fetchWithResetRetry, SendBudgetExhaustedError } from "../lib/upstream-retry";
import type { AuxiliaryModelSend } from "../lib/request-execution-budget";
import { estimateTokens } from "../lib/token-estimate";
import { sseFieldValue } from "../lib/sse-decoder";
import {
MAX_SIDECAR_RESPONSE_BYTES,
cancelReaderWithoutWaiting,
type WebSearchSource,
} from "./parse";
import { BASE_INSTRUCTION, IMAGE_INSTRUCTION, type SidecarOutcome, type SidecarSettings } from "./executor";
/** Hardcoded per-turn search bound handed to the server tool (mirrors the loop's maxSearches intent). */
const ANTHROPIC_MAX_USES = 3;
/** Answer budget; the injected tool_result is clamped downstream, so this only bounds the sidecar turn. */
const ANTHROPIC_MAX_TOKENS = 8192;
/** A terminal exactly at the wire cap must prove EOF without holding a reader indefinitely. */
const ANTHROPIC_CAP_EOF_PROBE_TIMEOUT_MS = 1_000;
function isRec(v: unknown): v is Record<string, unknown> {
return !!v && typeof v === "object" && !Array.isArray(v);
}
/** Read at most `MAX_SIDECAR_RESPONSE_BYTES` of an untrusted upstream body, then stop reading. */
async function readBoundedText(res: Response): Promise<string> {
if (!res.body) return "";
const reader = res.body.getReader();
const decoder = new TextDecoder();
let out = "";
let seen = 0;
try {
for (;;) {
const { done, value } = await reader.read();
if (done) break;
const remaining = MAX_SIDECAR_RESPONSE_BYTES - seen;
const accepted = value.byteLength <= remaining ? value : value.subarray(0, remaining);
seen += accepted.byteLength;
out += decoder.decode(accepted, { stream: true });
if (seen >= MAX_SIDECAR_RESPONSE_BYTES) {
cancelReaderWithoutWaiting(reader, "sidecar error body byte limit reached");
break;
}
}
out += decoder.decode();
} catch {
/* a failed error-body read must not mask the HTTP status we are about to report */
}
return out;
}
/**
* Fold an Anthropic Messages SSE stream (a web_search_20250305 turn) into a WebSearchResult.
*
* Anthropic streams the FULL `web_search_tool_result.content` array on `content_block_start` (not via
* deltas), so sources are collected there; the answer text arrives as `text_delta` events, and
* `citations_delta` (web_search_result_location) contributes any additional cited URLs. A
* `web_search_tool_result_error` content object yields an error. Never throws; partial text is
* retained with an error when the search or stream did not complete successfully.
*/
export async function parseAnthropicSidecarSSE(res: Response): Promise<SidecarOutcome> {
const sources: WebSearchSource[] = [];
const seen = new Set<string>();
const pushSource = (url: unknown, title: unknown): void => {
if (typeof url !== "string" || url.length === 0 || seen.has(url)) return;
seen.add(url);
sources.push(typeof title === "string" && title.length > 0 ? { url, title } : { url });
};
let text = "";
let sawToolResultError = false;
let failure: string | undefined;
let sawMessageStop = false;
let cleanEof = false;
let stopReason: string | undefined;
if (!res.body) return { text: "", sources, error: "anthropic sidecar returned no response body" };
const decoder = new TextDecoder();
const reader = res.body.getReader();
let buffer = "";
let responseBytes = 0;
const handleFrame = (data: Record<string, unknown>, type: string, complete: boolean): void => {
if (type === "ping") return;
if (sawMessageStop) failure ??= "anthropic sidecar returned data after completion";
cleanEof = false;
if (type === "error") {
failure ??= "anthropic sidecar returned a stream error";
} else if (type === "message_stop") {
sawMessageStop = true;
} else if (type === "message_delta") {
const delta = isRec(data.delta) ? data.delta : {};
if (typeof delta.stop_reason === "string") {
stopReason = delta.stop_reason;
cleanEof = complete;
}
}
if (type === "content_block_start") {
const block = isRec(data.content_block) ? data.content_block : {};
if (block.type === "web_search_tool_result") {
if (Array.isArray(block.content)) {
for (const hit of block.content) {
if (isRec(hit) && hit.type === "web_search_result") pushSource(hit.url, hit.title);
}
} else if (isRec(block.content) && block.content.type === "web_search_tool_result_error") {
sawToolResultError = true;
}
}
} else if (type === "content_block_delta") {
const delta = isRec(data.delta) ? data.delta : {};
if (delta.type === "text_delta" && typeof delta.text === "string") {
text += delta.text;
} else if (delta.type === "citations_delta") {
const citation = isRec(delta.citation) ? delta.citation : {};
if (citation.type === "web_search_result_location") pushSource(citation.url, citation.title);
}
}
};
// Parse one SSE frame's `data:` payload and fold it. Shared by the streaming loop and the EOF flush.
const processFrame = (rawFrame: string, complete = true): void => {
const invalidFrame = (): void => {
cleanEof = false;
failure ??= sawMessageStop
? "anthropic sidecar returned data after completion"
: "anthropic sidecar returned an invalid stream frame";
};
const dataLines: string[] = [];
let eventName: string | undefined;
for (const line of rawFrame.split("\n")) {
const dataValue = sseFieldValue(line, "data");
if (dataValue !== null) dataLines.push(dataValue);
const eventValue = sseFieldValue(line, "event");
if (eventValue !== null) eventName = eventValue;
}
if (eventName === "ping") return;
if (dataLines.length === 0 && (complete || rawFrame.split("\n").every(line => !line.trim() || line.startsWith(":")))) return;
const dataLine = dataLines.join("\n");
if (!dataLine || dataLine === "[DONE]") { invalidFrame(); return; }
let data: unknown;
try { data = JSON.parse(dataLine); } catch { invalidFrame(); return; }
if (isRec(data)) {
const type = eventName || (typeof data.type === "string" ? data.type : "");
handleFrame(data, type, complete);
} else invalidFrame();
};
const processCompleteFrames = (): void => {
let sep: number;
while ((sep = buffer.indexOf("\n\n")) !== -1) {
const rawFrame = buffer.slice(0, sep);
buffer = buffer.slice(sep + 2);
processFrame(rawFrame);
}
};
const verifyEofAtCap = async (): Promise<boolean> => {
let timer: ReturnType<typeof setTimeout> | undefined;
let expired = false;
const timeout = new Promise<null>(resolve => {
timer = setTimeout(() => { expired = true; resolve(null); }, ANTHROPIC_CAP_EOF_PROBE_TIMEOUT_MS);
});
try {
for (;;) {
if (expired) return false;
const next = await Promise.race([reader.read(), timeout]);
if (expired || next === null) return false;
if (next.done) return true;
if (next.value.byteLength > 0) return false;
// A source that synchronously produces empty chunks must not starve the probe timer.
await new Promise<void>(resolve => setTimeout(resolve, 0));
}
} catch {
return false;
} finally { if (timer !== undefined) clearTimeout(timer); }
};
try {
for (;;) {
const { done, value } = await reader.read();
if (done) break;
// A sidecar that never emits a frame separator would otherwise grow `buffer` without
// limit. Bound the accepted bytes exactly like the Responses sidecar parser does.
const remaining = MAX_SIDECAR_RESPONSE_BYTES - responseBytes;
const accepted = value.byteLength <= remaining ? value : value.subarray(0, remaining);
responseBytes += accepted.byteLength;
// Preserve a trailing CR until the next chunk so split CRLF remains one line break.
buffer = (buffer + decoder.decode(accepted, { stream: true })).replace(/\r\n/g, "\n").replace(/\r(?!$)/g, "\n");
processCompleteFrames();
if (responseBytes >= MAX_SIDECAR_RESPONSE_BYTES) {
// A trailing CR can complete a CR-only terminal delimiter at the exact boundary.
if (buffer.endsWith("\r")) {
buffer = buffer.slice(0, -1) + "\n";
processCompleteFrames();
}
const trailingCommentsOnly = buffer.split("\n").every(line => !line.trim() || line.startsWith(":"));
// A complete terminal or stop-reason delta at the cap needs bounded EOF proof; an
// oversized chunk or partial trailing frame is an error. Never await upstream teardown.
if ((!sawMessageStop && !cleanEof) || value.byteLength > remaining || !trailingCommentsOnly) {
failure ??= "anthropic sidecar response exceeded the byte limit";
} else if (!failure && !sawToolResultError
&& (stopReason === undefined || stopReason === "end_turn" || stopReason === "stop_sequence")
&& !(await verifyEofAtCap())) {
failure = "anthropic sidecar response byte limit reached before EOF";
}
cancelReaderWithoutWaiting(reader, "sidecar response byte limit reached");
buffer = "";
break;
}
}
// Flush the decoder and process any final unterminated frame (a stream that ends without \n\n).
buffer = (buffer + decoder.decode()).replace(/\r\n|\r/g, "\n");
processCompleteFrames();
if (buffer.trim().length > 0) processFrame(buffer, false);
} catch {
failure ??= "anthropic sidecar stream could not be read";
}
const trimmed = text.trim();
if (sawToolResultError) failure ??= "anthropic web search returned an error result";
if (stopReason !== undefined && stopReason !== "end_turn" && stopReason !== "stop_sequence") {
failure ??= "anthropic sidecar produced an incomplete answer";
}
if (!sawMessageStop && !cleanEof) failure ??= "anthropic sidecar stream ended before completion";
if (failure) return { text: trimmed, sources, error: failure };
if (trimmed.length === 0) {
return { text: "", sources, error: "anthropic sidecar produced no answer" };
}
return { text: trimmed, sources };
}
/**
* Execute ONE web search via a Claude sidecar through the STORED anthropic OAuth credential — the
* Anthropic-backed analog of runWebSearch. Resolves the helper model's permitted account (refresh handled)
* and reproduces the Claude Code OAuth fingerprint (identity system block first, oauth beta, client
* headers, stable session id) so the request is first-party-shaped. Never throws — returns `{error}`
* so the caller injects a graceful tool result.
*/
export async function runAnthropicWebSearch(
query: string,
providerName: string,
provider: OcxProviderConfig,
settings: SidecarSettings,
abortSignal?: AbortSignal,
config?: OcxConfig,
dispatchSidecarSend?: AuxiliaryModelSend,
): Promise<SidecarOutcome> {
const url = anthropicHelperMessagesUrl(provider.baseUrl);
let token: string;
let snapshot: OAuthAccessSnapshot | undefined;
const capturedTarget = provider.baseUrl;
try {
if (config && isAnthropicInstanceId(providerName)) {
snapshot = await resolveAnthropicHelperSnapshot(config, providerName, settings.model);
token = snapshot.accessToken;
} else {
token = await getAnthropicSidecarAccessToken(providerName, settings.model, config);
}
} catch (e) {
return { text: "", sources: [], error: `anthropic sidecar auth failed: ${publicOAuthAuthenticationErrorMessage(e)}` };
}
const headers: Record<string, string> = {
"Content-Type": "application/json",
"anthropic-version": "2023-06-01",
"Accept": "text/event-stream",
"User-Agent": CLAUDE_CLI_USER_AGENT,
"Authorization": `Bearer ${token}`,
"anthropic-beta": ANTHROPIC_OAUTH_BETA,
...CLAUDE_CODE_HEADERS,
"X-Claude-Code-Session-Id": claudeCodeSessionId(token),
"x-client-request-id": crypto.randomUUID(),
};
if (provider.headers) Object.assign(headers, provider.headers);
const instruction = settings.describeImages ? BASE_INSTRUCTION + IMAGE_INSTRUCTION : BASE_INSTRUCTION;
const body = {
model: settings.model,
max_tokens: ANTHROPIC_MAX_TOKENS,
// Sonnet 5 defaults to adaptive thinking when omitted; keep the sidecar fast/cheap (audit F2).
// The per-family off switch (disabled, between_tools or a low effort) lives in the model contract.
...sidecarThinkingOff(settings.model),
// OAuth fingerprint requires the Claude Code identity as the FIRST system block (audit F6/anthropic.ts).
system: [
{ type: "text", text: CLAUDE_CODE_SYSTEM_INSTRUCTION },
{ type: "text", text: instruction },
],
messages: [{ role: "user", content: [{ type: "text", text: query }] }],
tools: [{ type: "web_search_20250305", name: "web_search", max_uses: ANTHROPIC_MAX_USES }],
stream: true,
};
const dispatch = (target: string, init: RequestInit) => snapshot && config
? fetchAnthropicHelper(config, snapshot, settings.model, capturedTarget, target, init)
: fetch(target, init);
const linkedSignal = signalWithTimeout(settings.timeoutMs, abortSignal);
const sidecarExit = sidecarEnter("web-search");
const t0 = Date.now();
const serializedBody = JSON.stringify(body);
const sendTarget = {
poolId: snapshot?.provider ?? providerName,
// Anthropic has no durable identity scope; never borrow the routed Codex account.
identityId: "",
targetKey: `anthropic-web-search:${crypto.randomUUID()}`,
// This helper contains only text/tool definitions; include the full wire envelope conservatively.
estimate: { inputTokens: Math.max(1, estimateTokens(serializedBody, settings.model)), outputCeilingTokens: body.max_tokens },
};
try {
const res = await fetchWithResetRetry(
// The replay needs `keepalive: false` to leave the half-closed pooled socket; Bun has
// ignored a bare `Connection: close` (oven-sh/bun#20492).
recovery => {
const run = () => dispatch(url, applyUpstreamRecoveryInit({
method: "POST",
redirect: "manual",
headers,
body: serializedBody,
signal: linkedSignal.signal,
}, recovery));
return dispatchSidecarSend ? dispatchSidecarSend(sendTarget, run) : run();
},
{ replaySafe: true, abortSignal: linkedSignal.signal, label: "web-search-sidecar-anthropic" },
);
// Guard before any branch reads the body: the failure branch's `res.text()` ran ahead of
// the success-path guard, reopening the fetch-resolution-to-reader-attach race
// (found investigating #1419).
const detachBodyGuard = cancelBodyOnAbort(res.body, linkedSignal.signal);
if (!res.ok) {
// Untrusted upstream error bodies are only used for an auth-failure message, so read a
// bounded prefix instead of buffering an arbitrarily large response.
const t = await readBoundedText(res);
detachBodyGuard();
console.warn(`[web-search] anthropic sidecar HTTP ${res.status} for query "${query.slice(0, 80)}" (${Date.now() - t0}ms)`);
if (res.status === 401) {
return { text: "", sources: [], error: `anthropic sidecar auth failed: ${publicOAuthAuthenticationErrorMessage(new Error(t))}` };
}
// Upstream bodies are untrusted and may contain credentials, paths, or provider diagnostics.
return { text: "", sources: [], error: `sidecar HTTP ${res.status}` };
}
try {
return await parseAnthropicSidecarSSE(res);
} finally {
detachBodyGuard();
}
} catch (e) {
const kind = e instanceof SendBudgetExhaustedError ? "send_budget_exhausted"
: e instanceof Error && e.name === "TimeoutError" ? "timeout" : "connect_error";
console.warn(`[web-search] anthropic sidecar ${kind} for query "${query.slice(0, 80)}" (${Date.now() - t0}ms)`);
return { text: "", sources: [], error: `anthropic sidecar ${kind}` };
} finally {
sidecarExit();
linkedSignal.cleanup();
}
}