Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as CodexSchema from "effect-codex-app-server/schema";
import type {
ModelCapabilities,
ProviderOptionDescriptor,
ServerProviderModel,
} from "@akeru/contracts";
import { PREFERRED_DEFAULT_CODEX_MODELS } from "@akeru/contracts";
import { createModelCapabilities } from "@akeru/shared/model";
export const REASONING_EFFORT_LABELS = {
none: "None",
minimal: "Minimal",
low: "Low",
medium: "Medium",
high: "High",
xhigh: "Extra High",
max: "Max",
ultra: "Ultra",
} satisfies Record<string, string>;
export const DEFAULT_SERVICE_TIER_ID = "default";
export function reasoningEffortLabel(reasoningEffort: string): string {
return (
Object.entries(REASONING_EFFORT_LABELS).find(([effort]) => effort === reasoningEffort)?.[1] ??
reasoningEffort
);
}
export function mapCodexModelCapabilities(
model: CodexSchema.V2ModelListResponse__Model,
): ModelCapabilities {
const reasoningOptions = model.supportedReasoningEfforts.map(({ reasoningEffort }) =>
reasoningEffort === model.defaultReasoningEffort
? {
id: reasoningEffort,
label: reasoningEffortLabel(reasoningEffort),
isDefault: true,
}
: {
id: reasoningEffort,
label: reasoningEffortLabel(reasoningEffort),
},
);
const defaultReasoning = reasoningOptions.find((option) => option.isDefault)?.id;
const serviceTiers =
model.serviceTiers && model.serviceTiers.length > 0
? model.serviceTiers
: (model.additionalSpeedTiers ?? []).map((id) => ({
id,
name: id === "fast" ? "Fast" : id,
description: "",
}));
const catalogDefaultServiceTier = serviceTiers.some(
(tier) => tier.id === model.defaultServiceTier,
)
? model.defaultServiceTier
: null;
const defaultServiceTier = catalogDefaultServiceTier ?? DEFAULT_SERVICE_TIER_ID;
const optionDescriptors: ProviderOptionDescriptor[] = [];
if (reasoningOptions.length > 0) {
optionDescriptors.push({
id: "reasoningEffort",
label: "Reasoning",
type: "select",
options: reasoningOptions,
...(defaultReasoning ? { currentValue: defaultReasoning } : {}),
});
}
if (serviceTiers.length > 0) {
optionDescriptors.push({
id: "serviceTier",
label: "Service Tier",
type: "select",
options: [
{
id: DEFAULT_SERVICE_TIER_ID,
label: "Standard",
...(defaultServiceTier === DEFAULT_SERVICE_TIER_ID ? { isDefault: true } : {}),
},
...serviceTiers.map((tier) => ({
id: tier.id,
label: tier.name,
...(tier.description ? { description: tier.description } : {}),
...(defaultServiceTier === tier.id ? { isDefault: true } : {}),
})),
],
currentValue: defaultServiceTier,
});
}
return createModelCapabilities({
optionDescriptors,
});
}
export const toDisplayName = (model: CodexSchema.V2ModelListResponse__Model): string => {
// Capitalize 'gpt' to 'GPT-' and capitalize any letter following a dash
return model.displayName
.replace(/^gpt/i, "GPT") // Handle start with 'gpt' or 'GPT'
.replace(/-([a-z])/g, (_, c) => "-" + c.toUpperCase());
};
export function parseCodexModelListResponse(
response: CodexSchema.V2ModelListResponse,
): ReadonlyArray<ServerProviderModel> {
return response.data.map((model) => ({
slug: model.model,
name: toDisplayName(model),
isCustom: false,
...(model.isDefault ? { isDefault: true } : {}),
capabilities: mapCodexModelCapabilities(model),
}));
}
/**
* Prefer our own default-model ranking when one of the preferred slugs is in
* the live catalog; otherwise keep whatever Codex itself flagged as default.
*/
export function applyPreferredCodexDefaultModel(
models: ReadonlyArray<ServerProviderModel>,
): ReadonlyArray<ServerProviderModel> {
const preferredSlug = PREFERRED_DEFAULT_CODEX_MODELS.find((slug) =>
models.some((model) => model.slug === slug && !model.isCustom),
);
if (!preferredSlug) {
return models;
}
return models.map((model) => {
if (model.slug === preferredSlug) {
return model.isDefault ? model : { ...model, isDefault: true };
}
if (!model.isDefault) {
return model;
}
const { isDefault: _isDefault, ...rest } = model;
return rest;
});
}
export function appendCustomCodexModels(
models: ReadonlyArray<ServerProviderModel>,
customModels: ReadonlyArray<string>,
): ReadonlyArray<ServerProviderModel> {
if (customModels.length === 0) {
return models;
}
const seen = new Set(models.map((model) => model.slug));
const fallbackCapabilities = models.find((model) => model.capabilities)?.capabilities ?? null;
const customEntries: ServerProviderModel[] = [];
for (const rawModel of customModels) {
const slug = rawModel.trim();
if (!slug || seen.has(slug)) {
continue;
}
seen.add(slug);
customEntries.push({
slug,
name: slug,
isCustom: true,
capabilities: fallbackCapabilities,
});
}
return customEntries.length === 0 ? models : [...models, ...customEntries];
}