@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
133 lines (120 loc) • 5.7 kB
text/typescript
/**
* Opaque reasoning state and credential domains for native Messages sends (PF-10).
*
* A thinking block's `signature` and a `redacted_thinking` block's `data` are opaque to this
* proxy: they were minted by some Anthropic deployment for some credential, and only that side
* can verify or decrypt them. The native Messages lane therefore forwards them only to Anthropic
* itself (`api.anthropic.com` over HTTPS). For any other destination they are removed from the
* body that is sent — the signature field is dropped and the thinking text kept, a
* `redacted_thinking` block is dropped whole — and the caller's source body is left untouched,
* so the next build for the next destination starts from the full state again.
*
* A credential domain is the pair a destination is trusted as: the provider's base host and the
* class of credential it is reached with. Two sends share a domain only when both match; a key
* rotation within one provider keeps it, a move to another host or another credential class does
* not. Every build decides from its own domain, never from an earlier build's output.
*
* LEAF MODULE: type-only imports, no side effects, never logs or returns what it removed.
*/
import type { AnthropicProviderClass } from "../adapters/anthropic/beta-allowlist";
import type { OcxProviderConfig } from "../types";
type Rec = Record<string, unknown>;
function isRec(value: unknown): value is Rec {
return value !== null && typeof value === "object" && !Array.isArray(value);
}
/** Anthropic's own API host. Nothing else is first-party, including look-alike subdomains. */
export const FIRST_PARTY_ANTHROPIC_HOST = "api.anthropic.com";
export type CredentialAuthClass = "key" | "oauth" | "forward" | "local" | "unknown";
export interface CredentialDomain {
/** Lower-cased `host` (with a non-default port) of the provider's base URL. */
readonly host: string;
readonly authClass: CredentialAuthClass;
/** HTTPS to `api.anthropic.com` on the default port, with no userinfo. */
readonly firstPartyAnthropic: boolean;
}
function authClassOf(authMode: OcxProviderConfig["authMode"]): CredentialAuthClass {
switch (authMode) {
case undefined:
case "key":
return "key";
case "oauth":
case "forward":
case "local":
return authMode;
default:
return "unknown";
}
}
/** The credential domain a provider is reached in, or `undefined` for a malformed base URL. */
export function credentialDomainFor(
provider: Pick<OcxProviderConfig, "baseUrl" | "authMode">,
): CredentialDomain | undefined {
let url: URL;
try {
url = new URL(provider.baseUrl);
} catch {
return undefined;
}
const firstPartyAnthropic = url.protocol === "https:"
&& url.hostname.toLowerCase() === FIRST_PARTY_ANTHROPIC_HOST
&& url.port === ""
&& url.username === ""
&& url.password === "";
return { host: url.host.toLowerCase(), authClass: authClassOf(provider.authMode), firstPartyAnthropic };
}
/** Whether two sends share one credential domain. An unknown domain shares none. */
export function sameCredentialDomain(a: CredentialDomain | undefined, b: CredentialDomain | undefined): boolean {
return a !== undefined && b !== undefined && a.host === b.host && a.authClass === b.authClass;
}
/** The beta-allowlist class of a provider: first-party only for Anthropic's own API. */
export function anthropicProviderClass(provider: Pick<OcxProviderConfig, "baseUrl" | "authMode">): AnthropicProviderClass {
return credentialDomainFor(provider)?.firstPartyAnthropic ? "first-party" : "compatible";
}
function isOpaqueBlock(block: unknown): boolean {
if (!isRec(block)) return false;
if (block.type === "redacted_thinking") return true;
return block.type === "thinking" && Object.hasOwn(block, "signature");
}
/** Whether a Messages body carries any thinking signature or `redacted_thinking` block. */
export function messagesBodyHasOpaqueState(body: Readonly<Rec>): boolean {
if (!Array.isArray(body.messages)) return false;
for (const message of body.messages) {
if (isRec(message) && Array.isArray(message.content) && message.content.some(isOpaqueBlock)) return true;
}
return false;
}
export interface OpaqueStateResult {
/** The body to send. The input itself when nothing had to change. */
body: Rec;
/** Whether opaque state was removed for this destination. */
stripped: boolean;
}
/**
* The body a destination may receive. First-party Anthropic keeps every signature and redacted
* block; any other or unknown destination gets a copy without them. Copy-on-write: only the
* messages that change are copied, and the input is never mutated. A message left with no
* content is dropped rather than sent empty.
*/
export function opaqueStateForDestination(body: Rec, domain: CredentialDomain | undefined): OpaqueStateResult {
if (domain?.firstPartyAnthropic || !messagesBodyHasOpaqueState(body)) return { body, stripped: false };
const messages: unknown[] = [];
for (const message of body.messages as unknown[]) {
if (!isRec(message) || !Array.isArray(message.content) || !message.content.some(isOpaqueBlock)) {
messages.push(message);
continue;
}
const content: unknown[] = [];
for (const block of message.content) {
if (!isOpaqueBlock(block)) {
content.push(block);
continue;
}
const opaque = block as Rec;
if (opaque.type === "redacted_thinking") continue;
const { signature: _signature, ...visible } = opaque;
content.push(visible);
}
if (content.length > 0) messages.push({ ...message, content });
}
return { body: { ...body, messages }, stripped: true };
}