@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
430 lines (406 loc) • 18.2 kB
text/typescript
/*
* Derived from rsvedant/opencode-windsurf-auth (src/cloud-direct/), MIT licensed,
* Copyright (c) 2026 Vedant. The full notice is in ./index.ts.
*/
/**
* Per-account model catalog from Cognition's `GetCascadeModelConfigs`.
*
* Why this exists — issue #14:
* The cloud's `GetChatMessage` returns a single Connect-streaming EOS frame
* containing `{"error":{"code":"permission_denied","message":"an internal
* error occurred (trace ID: <hex>)"}}` whenever the caller's account tier
* does not include the requested `model_uid`. Reproduced byte-identical on a
* `TEAMS_TIER_DEVIN_FREE` account for every Anthropic/Gemini/Premium UID
* (only `swe-1-6-slow` streamed a real reply). The user-facing message is
* indistinguishable from a transient server fault — issue #14's reporter
* spent multiple sessions guessing.
*
* The pre-flight here checks the per-account catalog (`disabled` flag on
* `ClientModelConfig` field #4) BEFORE we spend a roundtrip on a request
* the cloud will refuse. When the lookup fails (network, auth, schema
* drift) we silently fall back to the chat path so a transient catalog
* outage can't take chat down with it.
*
* Schema (#1/#4/#22 verified against the bundled `extension.js`,
* `exa.codeium_common_pb.ClientModelConfig`; #18 identified from a live
* catalog dump against vendor-known windows; #5 corroborated against the
* public WindsurfAPI `ClientModelConfig` documentation):
*
* GetCascadeModelConfigsResponse {
* #1 client_model_configs: repeated ClientModelConfig
* }
* ClientModelConfig {
* #1 label string
* #4 disabled bool ← the gate this module reads
* #5 supports_images bool ← tri-state: absent stays unknown
* #18 max_input_tokens varint ← per-account context window
* #22 model_uid string ← what `GetChatMessage` accepts
* #23 model_info ModelInfo { #6 features { #15 supports_thinking },
* #13 max_output_tokens, #23 model_family_uid }
* #30 family_metadata ModelFamilyMetadata { #1 family_label,
* #2 repeated Entry { #1 axis key, #2 { #1 order, #2 name } },
* #3 is_default_model_in_family }
* #31 is_default_model_in_family bool
* }
*
* #23/#30/#31 were read back from a live 267-row catalog (2026-09-27): every
* current row names its family, and each family marks one default member.
* Legacy `MODEL_*` rows carry no #30.
*
* Disabled semantics: TRUE means "this UID exists in the catalog but the
* caller's account/tier cannot run inference against it." BYOK models
* surface as `disabled: false` so users with their own provider keys still
* pass through — the only way they fail at chat time is a missing key,
* which surfaces with a different message.
*
* Cache: per (apiServerUrl, apiKey) for {@link CATALOG_TTL_MS}. Cognition
* doesn't bump catalog entries mid-session in normal operation, so a 10-min
* TTL trades one extra roundtrip per ~10 min for clear errors on every chat.
*/
import * as crypto from 'crypto';
import { buildMetadata } from './metadata.js';
import { getCachedUserJwt } from './auth.js';
import { encodeMessage, iterFields } from './wire.js';
import { resolveDevinApiBaseUrl } from '../../../oauth/devin/api-base.js';
/** 10 minutes — see header. */
const CATALOG_TTL_MS = 10 * 60 * 1000;
/** Catalog endpoint inactivity timeout. Cognition responds in <500ms steady-state. */
const CATALOG_FETCH_TIMEOUT_MS = 10_000;
export interface ModelCatalogEntry {
/** Cloud-side `model_uid` (e.g. `claude-opus-4-7-medium`). */
modelUid: string;
/** Human label (e.g. `Claude Opus 4.7 Medium`) — used in error messages. */
label: string;
/** True when the caller's account tier cannot use this UID for chat. */
disabled: boolean;
/**
* Maximum input tokens the account may send this model, from
* `ClientModelConfig` field #18.
*
* Cognition publishes no context-window numbers anywhere: not in the Devin
* CLI or Desktop model pages, not in the SWE-2 or SWE-1.7 announcements, and
* not in the Windsurf model reference, which has no such table. The only
* numbers on those pages are long-context PRICING thresholds, which are a
* different quantity. That makes this field the single first-party source,
* and it is per account rather than per model id.
*
* Absent when the entry omits the field, which is how a future schema change
* degrades: the caller keeps its static fallback instead of reporting zero.
*/
contextWindow?: number;
/**
* Image-input support from `ClientModelConfig` field #5, kept as a
* tri-state: a present `true` asserts text+image support, a present
* `false` asserts text-only, and an OMITTED field stays `undefined`
* (unknown). Deliberately unlike `disabled`, which defaults to false —
* collapsing "never asserted" into "text-only" was the #1796 regression
* (see src/providers/antigravity-models.ts).
*/
supportsImages?: boolean;
/** ModelInfo #13: the model's own output-token ceiling. */
maxOutputTokens?: number;
/** ModelInfo #6.15. */
supportsThinking?: boolean;
/** ModelInfo #23, e.g. `swe-1.7` for both `swe-1-7` and `swe-1-7-medium`. */
familyUid?: string;
/** ModelFamilyMetadata #1, e.g. `SWE-1.7`. */
familyLabel?: string;
/**
* ModelFamilyMetadata #2: this row's position on each of its family's axes,
* keyed by axis name (`Effort`, `Reasoning Effort`, `Fast Mode`, `1M Context`,
* `Thinking`, ...). Toggle axes such as `Fast Mode` carry only an order.
*/
familyAxes?: Record<string, DevinFamilyAxisValue>;
/** #31 (or #30.3): the member the family selects when nothing is asked for. */
isFamilyDefault?: boolean;
}
export interface DevinFamilyAxisValue {
order: number;
name?: string;
}
/**
* Rows whose catalog entry claims image support that the model does not have.
* Live 2026-09-27: `swe-1-6` answered "NOIMAGE" to a solid red PNG while
* `swe-1-6-fast` and `swe-2-medium` named the colour, so the image is dropped
* server-side without an error. Marking it text-only lets the vision fallback
* describe the image instead of the model silently never seeing it.
*/
const IMAGE_BLIND_UIDS = new Set(['swe-1-6']);
function parseFamilyMetadata(buf: Buffer): { label?: string; axes: Record<string, DevinFamilyAxisValue>; isDefault: boolean } {
let label: string | undefined;
let isDefault = false;
const axes: Record<string, DevinFamilyAxisValue> = {};
for (const f of iterFields(buf)) {
if (f.num === 1 && f.wire === 2 && Buffer.isBuffer(f.value)) label = f.value.toString('utf8');
else if (f.num === 3 && f.wire === 0) isDefault = f.value === 1n;
else if (f.num === 2 && f.wire === 2 && Buffer.isBuffer(f.value)) {
let key = '';
const value: DevinFamilyAxisValue = { order: 0 };
for (const e of iterFields(f.value)) {
if (e.num === 1 && e.wire === 2 && Buffer.isBuffer(e.value)) key = e.value.toString('utf8');
else if (e.num === 2 && e.wire === 2 && Buffer.isBuffer(e.value)) {
for (const v of iterFields(e.value)) {
if (v.num === 1 && v.wire === 0) value.order = Number(v.value);
else if (v.num === 2 && v.wire === 2 && Buffer.isBuffer(v.value)) value.name = v.value.toString('utf8');
}
}
}
if (key) axes[key] = value;
}
}
return { ...(label ? { label } : {}), axes, isDefault };
}
function parseModelInfo(buf: Buffer): { maxOutputTokens?: number; familyUid?: string; supportsThinking?: boolean } {
const out: { maxOutputTokens?: number; familyUid?: string; supportsThinking?: boolean } = {};
for (const f of iterFields(buf)) {
if (f.num === 13 && typeof f.value === 'bigint' && f.value > 0n) out.maxOutputTokens = Number(f.value);
else if (f.num === 23 && f.wire === 2 && Buffer.isBuffer(f.value) && f.value.length > 0) out.familyUid = f.value.toString('utf8');
else if (f.num === 6 && f.wire === 2 && Buffer.isBuffer(f.value)) {
for (const g of iterFields(f.value)) if (g.num === 15 && g.wire === 0) out.supportsThinking = g.value === 1n;
}
}
return out;
}
export interface CacheEntry {
/** Lookup keyed by `model_uid`. */
byUid: Map<string, ModelCatalogEntry>;
fetchedAt: number;
/** Cache key components, captured for invalidation/log purposes. */
apiKey: string;
host: string;
}
let cached: CacheEntry | null = null;
let inFlight: Promise<CacheEntry> | null = null;
let inFlightKey: string | null = null;
// Bumped on clearCachedCatalog so an in-flight fetch racing with a clear
// can't repopulate the cache with a just-invalidated catalog.
let cacheEpoch = 0;
function flightKey(apiKey: string, host: string): string {
return `${host}\x1f${apiKey}`;
}
/**
* Parse a GetCascadeModelConfigsResponse buffer into a UID-keyed map.
* A malformed catalog returns an empty map.
*/
export function parseCatalogBuffer(buf: Buffer, apiKey: string, host: string): CacheEntry {
// GetCascadeModelConfigsResponse #1 (repeated ClientModelConfig)
const byUid = new Map<string, ModelCatalogEntry>();
for (const f of iterFields(buf)) {
if (f.num !== 1 || f.wire !== 2 || !Buffer.isBuffer(f.value)) continue;
let label = '';
let modelUid = '';
let disabled = false;
let contextWindow = 0;
let supportsImages: boolean | undefined;
let info: ReturnType<typeof parseModelInfo> = {};
let family: ReturnType<typeof parseFamilyMetadata> | undefined;
let isFamilyDefault = false;
for (const sf of iterFields(f.value as Buffer)) {
if (sf.num === 1 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
label = (sf.value as Buffer).toString('utf8');
} else if (sf.num === 4 && sf.wire === 0) {
// #4 = disabled (bool, varint 0/1)
disabled = sf.value === 1n;
} else if (sf.num === 5 && sf.wire === 0) {
// #5 = supportsImages (bool, varint 0/1). Absent stays unknown — see
// ModelCatalogEntry; do not default it like disabled.
supportsImages = sf.value === 1n;
} else if (sf.num === 18 && sf.wire === 0) {
// #18 = max input tokens. Identified by dumping a live catalog and
// reading the varints back against models whose windows are known from
// their upstream vendors: 1000000 on the Claude and GPT rows, 1048576
// on Gemini/Kimi/GLM, 500000 on Grok, 262000 on swe-2.
contextWindow = Number(sf.value);
} else if (sf.num === 22 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
modelUid = (sf.value as Buffer).toString('utf8');
} else if (sf.num === 23 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
info = parseModelInfo(sf.value);
} else if (sf.num === 30 && sf.wire === 2 && Buffer.isBuffer(sf.value)) {
family = parseFamilyMetadata(sf.value);
} else if (sf.num === 31 && sf.wire === 0) {
isFamilyDefault = sf.value === 1n;
}
}
if (IMAGE_BLIND_UIDS.has(modelUid)) supportsImages = false;
if (modelUid.length > 0) {
byUid.set(modelUid, {
modelUid,
label: label || modelUid,
disabled,
...(contextWindow > 0 ? { contextWindow } : {}),
...(supportsImages !== undefined ? { supportsImages } : {}),
...info,
...(family?.label ? { familyLabel: family.label } : {}),
...(family ? { familyAxes: family.axes } : {}),
...(isFamilyDefault || family?.isDefault ? { isFamilyDefault: true } : {}),
});
}
}
return { byUid, fetchedAt: Date.now(), apiKey, host };
}
/**
* Fetch the cascade model catalog for `(apiKey, host)` and parse the
* subset of `ClientModelConfig` we care about into a UID-keyed map.
*
* Throws on transport/auth failure so the caller can decide whether to fall
* back to "skip pre-flight". Does NOT throw on an unexpected response body —
* a malformed catalog returns an empty map, treated the same as "model not
* listed" by the chat pre-flight.
*
* Uses only an internal timeout — caller cancellation is handled by
* getCachedCatalog racing each caller's signal against the shared promise.
*/
async function fetchCatalog(apiKey: string, host: string): Promise<CacheEntry> {
const userJwt = await getCachedUserJwt(apiKey, host);
const metadata = buildMetadata({
apiKey,
userJwt,
sessionId: crypto.randomUUID(),
requestId: BigInt(Date.now()),
triggerId: crypto.randomUUID(),
});
// GetCascadeModelConfigsRequest { metadata: Metadata } — Metadata is #1.
const reqBody = encodeMessage(1, metadata);
// Internal 10s timeout so a stalled catalog endpoint can't deadlock chat.
// The shared fetch uses only this internal timeout — caller cancellation is
// handled by racing each caller's signal against the shared promise in
// getCachedCatalog, so one caller's abort never propagates to unrelated
// callers sharing the same in-flight fetch.
const ac = new AbortController();
const timer = setTimeout(
() => ac.abort(new Error(`catalog: fetch timeout (${CATALOG_FETCH_TIMEOUT_MS}ms)`)),
CATALOG_FETCH_TIMEOUT_MS,
);
let resp: Response;
try {
resp = await fetch(`${resolveDevinApiBaseUrl(host)}/exa.api_server_pb.ApiServerService/GetCascadeModelConfigs`, {
method: 'POST',
headers: { 'Content-Type': 'application/proto', 'Connect-Protocol-Version': '1' },
body: new Uint8Array(reqBody),
// This body carries the api_key; a redirect would replay it elsewhere.
redirect: 'error',
signal: ac.signal,
});
if (!resp.ok) {
// Status only: the error body can quote the api_key-bearing request.
throw new Error(`GetCascadeModelConfigs failed (HTTP ${resp.status})`);
}
// Read the body BEFORE clearing the timeout — fetch resolves on headers,
// not body completion. A stalled body would otherwise block indefinitely.
const buf = Buffer.from(await resp.arrayBuffer());
return parseCatalogBuffer(buf, apiKey, host);
} finally {
clearTimeout(timer);
}
}
/**
* Get the cached catalog for `(apiKey, host)`, fetching when missing or stale.
*
* Concurrent callers for the SAME (apiKey, host) share one in-flight fetch
* (no thundering herd on startup). Concurrent callers for DIFFERENT keys
* serialise the in-flight slot but only one of them holds it at a time —
* good enough for opencode's single-account-at-a-time usage pattern.
*
* Returns `null` on fetch failure (network, transient 5xx, auth issue). The
* caller treats `null` as "skip pre-flight and let the chat path surface the
* server-side error itself."
*/
export async function getCachedCatalog(
apiKey: string,
host: string,
signal?: AbortSignal,
): Promise<CacheEntry | null> {
if (cached && cached.apiKey === apiKey && cached.host === host) {
if (Date.now() - cached.fetchedAt < CATALOG_TTL_MS) {
return cached;
}
}
const key = flightKey(apiKey, host);
// Race the caller's signal against the shared promise so one caller's
// cancellation doesn't propagate to unrelated callers sharing the fetch.
const raceSignal = <T>(p: Promise<T>): Promise<T> =>
signal
? Promise.race([
p,
new Promise<T>((_, reject) => {
if (signal.aborted) reject(signal.reason);
else signal.addEventListener('abort', () => reject(signal.reason), { once: true });
}),
])
: p;
if (inFlight && inFlightKey === key) {
try {
return await raceSignal(inFlight);
} catch {
return null;
}
}
const promise = fetchCatalog(apiKey, host);
inFlight = promise;
inFlightKey = key;
const epochAtStart = cacheEpoch;
try {
const result = await raceSignal(promise);
if (cacheEpoch === epochAtStart) {
cached = result;
}
return result;
} catch {
return null;
} finally {
if (inFlight === promise) {
inFlight = null;
inFlightKey = null;
}
}
}
/**
* Drop the cached catalog. Call after logout/account switch so a fresh
* sign-in doesn't see a previous account's allow-list. Bumps the cache
* epoch so an in-flight fetch racing with this clear can't repopulate
* the cache with the just-invalidated catalog.
*/
export function clearCachedCatalog(): void {
cached = null;
inFlight = null;
inFlightKey = null;
cacheEpoch++;
}
/**
* Test seam: install a catalog as the live cache entry. Mirrors
* clearCachedCatalog's invalidation — the in-flight slot is dropped and the
* epoch bumped — so a fetch racing the seed cannot overwrite it, and a null
* entry resets the cache between tests.
*/
export function setCachedCatalogForTests(entry: CacheEntry | null): void {
cached = entry;
inFlight = null;
inFlightKey = null;
cacheEpoch++;
}
/**
* Tier-disabled error — thrown by the chat pre-flight when the catalog lists
* a model as `disabled: true` for this account. The message names the model
* and points at the plan page, replacing Cognition's opaque
* "an internal error occurred" trailer.
*/
export class ModelNotAvailableError extends Error {
constructor(
public readonly modelUid: string,
public readonly label: string,
public readonly reason: 'disabled' | 'not_listed',
) {
super(
reason === 'disabled'
? `Model "${label}" (uid=${modelUid}) is not enabled for your Cognition account. ` +
`The Cognition catalog returned it with disabled=true — meaning your current plan/tier ` +
`does not include this model. ` +
`Check the model picker on https://codeium.com/account, or pick a different model. ` +
`(This message replaces Cognition's "an internal error occurred" — same root cause.)`
: `Model uid "${modelUid}" is not listed in the Cognition catalog for your account. ` +
`Either the UID has been retired upstream or your account/region doesn't serve it. ` +
`Run \`curl http://127.0.0.1:42100/v1/models\` to see the canonical names your plan accepts.`,
);
this.name = 'ModelNotAvailableError';
}
}