@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
107 lines (97 loc) • 3.71 kB
text/typescript
import { exportPresentationLabel } from "../model-presentation";
import { OPENCODE_PROVIDER_ID } from "./constants";
import type { ExportContext, ManagedContribution } from "./contracts";
import { authoritativeContextWindow, normalizeExportModels, singleFragment } from "./model-metadata";
export interface RaycastAbility {
supported: boolean;
}
export type RaycastAbilityName =
| "temperature"
| "vision"
| "system_message"
| "tools"
| "reasoning_effort";
export interface RaycastModelEntry {
id: string;
name: string;
context?: number;
abilities: Record<RaycastAbilityName, RaycastAbility>;
}
export interface RaycastProviderEntry {
id: string;
name: string;
base_url: string;
models: RaycastModelEntry[];
}
export interface RaycastGeneratedConfig {
providers: RaycastProviderEntry[];
}
/**
* Raycast appends `/chat/completions` to `base_url`, so the proxy's `/v1`
* root is passed through unchanged. The format has no safe credential
* interpolation, which is why the registry exposes it only on loopback.
*/
export function buildRaycastClientConfig(ctx: ExportContext): RaycastGeneratedConfig {
const models: RaycastModelEntry[] = normalizeExportModels(ctx.models).map(model => {
const hasLadder = (model.reasoningEfforts?.length ?? 0) > 0;
const context = authoritativeContextWindow(model.contextWindow);
return {
id: model.namespaced,
name: exportPresentationLabel(model),
...(context !== undefined ? { context } : {}),
abilities: {
temperature: { supported: !hasLadder },
vision: { supported: model.inputModalities?.includes("image") ?? false },
system_message: { supported: true },
// Existing client-export convention, not a verified per-model capability:
// ExportModel has no authoritative tool-support field.
tools: { supported: true },
reasoning_effort: { supported: hasLadder },
},
};
});
return {
providers: [
{ id: OPENCODE_PROVIDER_ID, name: "OpenCodex", base_url: ctx.baseUrl, models },
],
};
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
export function summarizeRaycast(
document: unknown,
): { modelCount: number; modelsWithoutLimits: number } {
const empty = { modelCount: 0, modelsWithoutLimits: 0 };
if (!isRecord(document) || !Array.isArray(document.providers)) return empty;
const providers = document.providers.filter(
provider => isRecord(provider) && provider.id === OPENCODE_PROVIDER_ID,
);
// An ambiguous managed provider has no meaningful summary either.
if (providers.length !== 1) return empty;
const provider: unknown = providers[0];
if (!isRecord(provider) || !Array.isArray(provider.models)) return empty;
const models = provider.models.filter((model): model is Record<string, unknown> => (
isRecord(model)
&& typeof model.id === "string" && model.id.trim().length > 0
&& typeof model.name === "string" && model.name.trim().length > 0
));
return {
modelCount: models.length,
modelsWithoutLimits: models.filter(model => (
typeof model.context !== "number" || authoritativeContextWindow(model.context) === undefined
)).length,
};
}
/**
* Raycast stores providers in a sequence. The stable id selector owns only
* OpenCodex's element, preserving user-defined providers around it.
*/
export function buildRaycastContribution(ctx: ExportContext): ManagedContribution {
const doc = buildRaycastClientConfig(ctx);
return singleFragment(
"raycast",
["providers", `[id=${OPENCODE_PROVIDER_ID}]`],
doc.providers[0]!,
);
}