Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import {
listProviderOutputOverrides,
persistOutputTokenOverride,
} from "@/lib/providerModels/outputTokenOverrides";
import {
getCustomModels,
getAllCustomModels,
addCustomModel,
removeCustomModel,
replaceCustomModels,
deleteSyncedAvailableModelsForProvider,
removeSyncedAvailableModel,
updateCustomModel,
getModelCompatOverrides,
mergeModelCompatOverride,
resetModelEndpointOverride,
getHiddenModelsByProvider,
type ModelCompatPatch,
} from "@/lib/db/models";
import {
getModelContextOverrideRecord,
setModelContextOverride,
removeModelContextOverride,
listModelContextOverrides,
} from "@/lib/db/modelContextOverrides";
import {
deleteManagedAvailableModelAliases,
deleteManagedAvailableModelAliasesForProvider,
syncManagedAvailableModelAliases,
} from "@/lib/providerModels/managedAvailableModels";
import {
AI_PROVIDERS,
isOpenAICompatibleProvider,
isAnthropicCompatibleProvider,
} from "@/shared/constants/providers";
import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
import { getRegisteredEndpointAdapterStatuses } from "@/lib/providerModels/endpointAdapterAvailability";
import { isHiddenForModality } from "@/shared/utils/modelVisibility";
export const dynamic = "force-dynamic";
import { providerModelMutationSchema } from "@/shared/validation/schemas";
import { isValidationFailure, validateBody } from "@/shared/validation/helpers";
function normalizeRequestedModelIds(
searchParams: URLSearchParams,
body: Record<string, unknown>
): string[] {
const bodyModelIds = Array.isArray(body.modelIds)
? body.modelIds
.filter((value): value is string => typeof value === "string")
.map((value) => value.trim())
.filter(Boolean)
: [];
const singleModelId = searchParams.get("modelId") || searchParams.get("model");
const allModelIds = [...bodyModelIds, ...(singleModelId ? [singleModelId.trim()] : [])];
return Array.from(new Set(allModelIds)).filter(Boolean);
}
/**
* GET /api/provider-models?provider=<id>
* List custom models (all providers if no provider param)
*/
export async function GET(request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
try {
const { searchParams } = new URL(request.url);
const provider = searchParams.get("provider");
const models = provider ? await getCustomModels(provider) : await getAllCustomModels();
const modelCompatOverrides = provider ? getModelCompatOverrides(provider) : [];
const modelOutputOverrides = listProviderOutputOverrides(provider);
const outputOverrides = new Map(
modelOutputOverrides.map((row) => [row.modelId, row.maxOutputTokenOverride])
);
// #4125: surface the manual/auto context-window override (Feature 5004 table) on
// each custom-model row so the UI can show/edit it without a second round trip.
const modelsWithContextOverride =
provider && Array.isArray(models)
? models.map((model: Record<string, unknown>) => {
const modelId = typeof model?.id === "string" ? model.id : null;
const record = modelId ? getModelContextOverrideRecord(provider, modelId) : null;
const outputOverride = modelId ? outputOverrides.get(modelId) : undefined;
const outputFields =
outputOverride === undefined ? {} : { maxOutputTokenOverride: outputOverride };
return record
? {
...model,
...outputFields,
contextWindowOverride: record.realContext,
contextWindowOverrideSource: record.source,
}
: { ...model, ...outputFields };
})
: models;
// #9203: surface the unified hidden-model map (customModels.isHidden +
// modelCompatOverrides.isHidden) so the client can filter every model source
// (system catalog, fallback, aliases, auto-fetched) — not just custom rows.
const hiddenModelsByProvider: Record<string, string[]> = {};
for (const [providerId, hiddenModelIds] of getHiddenModelsByProvider()) {
if (hiddenModelIds.size > 0) {
hiddenModelsByProvider[providerId] = [...hiddenModelIds];
}
}
// #14337: the block above attaches the override to CUSTOM-model rows only.
// A synced/imported model has no `customModels` row, so its override — which
// the PUT compatOnly branch has always accepted — was never readable, and the
// UI had no value to show or edit. Return the provider's overrides directly
// so a row without a custom entry can still carry one.
const modelContextOverrides = provider
? listModelContextOverrides()
.filter((override) => override.provider === provider)
.map((override) => ({
modelId: override.modelId,
contextWindowOverride: override.realContext,
contextWindowOverrideSource: override.source,
}))
: [];
return Response.json({
models: modelsWithContextOverride,
modelCompatOverrides: modelCompatOverrides.map((override) => ({
...override,
isHidden: isHiddenForModality(override, "chat"),
})),
modelContextOverrides,
modelOutputOverrides,
endpointAdapters: provider ? getRegisteredEndpointAdapterStatuses(provider) : {},
hiddenModelsByProvider,
});
} catch {
return Response.json(
{ error: { message: "Failed to fetch provider models", type: "server_error" } },
{ status: 500 }
);
}
}
/**
* POST /api/provider-models
* Body: { provider, modelId, modelName? }
*/
export async function POST(request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
let rawBody;
try {
rawBody = await request.json();
} catch {
return Response.json(
{ error: { message: "Invalid JSON body", type: "validation_error" } },
{ status: 400 }
);
}
try {
const validation = validateBody(providerModelMutationSchema, rawBody);
if (isValidationFailure(validation)) {
return Response.json({ error: validation.error }, { status: 400 });
}
const {
provider,
modelId,
modelName,
source,
apiFormat,
supportedEndpoints,
endpointCapabilitySource,
targetFormat,
// #1294: persist the per-model token limits set in the add-model form.
max_input_tokens: maxInputTokens,
max_output_tokens: maxOutputTokens,
// #1904: manual vision-capability override set in the add-model form.
supportsVision,
// #9820: optional video-generation job preset (job/poll path).
generationConfig,
isFree,
dimensions,
supportedInputTypes,
modelType,
} = validation.data;
const model = await addCustomModel(
provider,
modelId,
modelName,
source || "manual",
apiFormat,
supportedEndpoints,
targetFormat,
{
...(maxInputTokens != null ? { inputTokenLimit: maxInputTokens } : {}),
...(maxOutputTokens != null ? { outputTokenLimit: maxOutputTokens } : {}),
},
typeof supportsVision === "boolean" ? supportsVision : undefined,
generationConfig,
typeof isFree === "boolean" ? isFree : undefined,
{
...(typeof dimensions === "number" && dimensions > 0 ? { dimensions } : {}),
...(Array.isArray(supportedInputTypes) ? { supportedInputTypes } : {}),
...(typeof modelType === "string" ? { modelType } : {}),
...(endpointCapabilitySource ? { endpointCapabilitySource } : {}),
}
);
return Response.json({ model });
} catch (error) {
console.error("Error adding provider model:", error);
return Response.json(
{ error: { message: "Failed to add provider model", type: "server_error" } },
{ status: 500 }
);
}
}
/**
* PUT /api/provider-models
* Body: { provider, modelId, modelName?, apiFormat?, supportedEndpoints? }
*/
export async function PUT(request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
let rawBody;
try {
rawBody = await request.json();
} catch {
return Response.json(
{ error: { message: "Invalid JSON body", type: "validation_error" } },
{ status: 400 }
);
}
try {
const validation = validateBody(providerModelMutationSchema, rawBody);
if (isValidationFailure(validation)) {
return Response.json({ error: validation.error }, { status: 400 });
}
const {
provider,
modelId,
modelName,
apiFormat,
supportedEndpoints,
targetFormat,
normalizeToolCallId,
preserveOpenAIDeveloperRole,
upstreamHeaders,
compatByProtocol,
contextWindowOverride,
maxOutputTokenOverride,
supportsVision,
generationConfig,
isFree,
} = validation.data;
const raw = rawBody as Record<string, unknown>;
const updates: Record<string, unknown> = {};
if ("modelName" in raw) updates.modelName = modelName;
if ("apiFormat" in raw) updates.apiFormat = apiFormat;
if ("supportedEndpoints" in raw) updates.supportedEndpoints = supportedEndpoints;
if ("targetFormat" in raw) updates.targetFormat = targetFormat;
if ("normalizeToolCallId" in raw) updates.normalizeToolCallId = normalizeToolCallId;
if ("preserveOpenAIDeveloperRole" in raw)
updates.preserveOpenAIDeveloperRole = preserveOpenAIDeveloperRole;
if ("upstreamHeaders" in raw) updates.upstreamHeaders = upstreamHeaders;
if ("supportsVision" in raw) updates.supportsVision = supportsVision;
if ("isFree" in raw) updates.isFree = isFree;
// #9820: video-generation job preset — schema is non-nullable optional, so
// presence implies a well-formed { preset } object; null is rejected by Zod.
if ("generationConfig" in raw && generationConfig !== undefined) {
updates.generationConfig = generationConfig;
}
if ("compatByProtocol" in raw && compatByProtocol !== undefined) {
updates.compatByProtocol = compatByProtocol;
}
// #4125: manual context-window override — persisted in the Feature-5004
// `model_context_overrides` table (source="manual"), independent of the
// customModels JSON row, so it applies whether or not other fields changed.
let contextWindowOverrideResult: number | null | undefined;
if ("contextWindowOverride" in raw) {
if (contextWindowOverride == null) {
removeModelContextOverride(provider, modelId);
contextWindowOverrideResult = null;
} else {
setModelContextOverride(provider, modelId, contextWindowOverride, "manual");
contextWindowOverrideResult = contextWindowOverride;
}
}
const model = await updateCustomModel(provider, modelId, updates, {
createIfMissing: maxOutputTokenOverride === undefined || Object.keys(updates).length > 0,
});
if (!model) {
const rawKeys = Object.keys(raw);
// isFree is intentionally excluded: it has no compat-override home (customModels row only),
// so a PUT with isFree against a missing row must 404 rather than enter the compat branch.
const compatOnly =
rawKeys.length > 0 &&
rawKeys.every((k) =>
[
"provider",
"modelId",
"modelName",
"source",
"normalizeToolCallId",
"preserveOpenAIDeveloperRole",
"upstreamHeaders",
"compatByProtocol",
"contextWindowOverride",
"maxOutputTokenOverride",
"apiFormat",
"targetFormat",
"supportsVision",
].includes(k)
) &&
("normalizeToolCallId" in raw ||
"preserveOpenAIDeveloperRole" in raw ||
"upstreamHeaders" in raw ||
"compatByProtocol" in raw ||
"contextWindowOverride" in raw ||
"maxOutputTokenOverride" in raw ||
"apiFormat" in raw ||
"targetFormat" in raw ||
"supportsVision" in raw);
if (compatOnly) {
const knownProvider =
!!provider &&
(Object.prototype.hasOwnProperty.call(
AI_PROVIDERS as Record<string, unknown>,
provider
) ||
isOpenAICompatibleProvider(provider) ||
isAnthropicCompatibleProvider(provider));
if (!knownProvider) {
return Response.json(
{ error: { message: "Unknown provider", type: "validation_error" } },
{ status: 400 }
);
}
const patch: ModelCompatPatch = {};
if ("normalizeToolCallId" in raw && typeof normalizeToolCallId === "boolean") {
patch.normalizeToolCallId = normalizeToolCallId;
}
if ("preserveOpenAIDeveloperRole" in raw) {
patch.preserveOpenAIDeveloperRole =
preserveOpenAIDeveloperRole === null || typeof preserveOpenAIDeveloperRole === "boolean"
? preserveOpenAIDeveloperRole
: undefined;
}
if ("compatByProtocol" in raw && compatByProtocol && typeof compatByProtocol === "object") {
patch.compatByProtocol = compatByProtocol;
}
if ("upstreamHeaders" in raw) {
patch.upstreamHeaders =
upstreamHeaders === null || typeof upstreamHeaders === "object"
? upstreamHeaders
: undefined;
}
if ("apiFormat" in raw) {
patch.apiFormat = typeof apiFormat === "string" ? apiFormat : null;
}
if ("targetFormat" in raw) {
patch.targetFormat = typeof targetFormat === "string" ? targetFormat : null;
}
if ("supportsVision" in raw) {
patch.supportsVision =
supportsVision === null || typeof supportsVision === "boolean"
? supportsVision
: undefined;
}
if (Object.keys(patch).length > 0) {
mergeModelCompatOverride(provider, modelId, patch);
}
return Response.json({
ok: true,
...persistOutputTokenOverride(provider, modelId, maxOutputTokenOverride),
modelCompatOverrides: getModelCompatOverrides(provider),
...(contextWindowOverrideResult !== undefined
? { contextWindowOverride: contextWindowOverrideResult }
: {}),
});
}
return Response.json(
{ error: { message: "Model not found", type: "not_found" } },
{ status: 404 }
);
}
return Response.json({
model,
...persistOutputTokenOverride(provider, modelId, maxOutputTokenOverride),
...(contextWindowOverrideResult !== undefined
? { contextWindowOverride: contextWindowOverrideResult }
: {}),
});
} catch (error) {
console.error("Error updating provider model:", error);
return Response.json(
{ error: { message: "Failed to update provider model", type: "server_error" } },
{ status: 500 }
);
}
}
/**
* PATCH /api/provider-models?provider=<id>&modelId=<modelId>
* Body: { isHidden: boolean, modelIds?: string[] }
*/
export async function PATCH(request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
let rawBody;
try {
rawBody = await request.json();
} catch {
return Response.json(
{ error: { message: "Invalid JSON body", type: "validation_error" } },
{ status: 400 }
);
}
try {
const { searchParams } = new URL(request.url);
const provider = searchParams.get("provider");
const body =
rawBody && typeof rawBody === "object" && !Array.isArray(rawBody)
? (rawBody as Record<string, unknown>)
: {};
if (!provider) {
return Response.json(
{ error: { message: "provider query param is required", type: "validation_error" } },
{ status: 400 }
);
}
if (typeof body.isHidden !== "boolean") {
return Response.json(
{ error: { message: "isHidden boolean is required", type: "validation_error" } },
{ status: 400 }
);
}
// #12172: optional modality scope (e.g. "chat", "images") so hiding a model on one
// registry surface does not also hide an identically-ID'd model on another one.
// Omitted = legacy "hide everywhere" behavior, unchanged for existing callers.
if (typeof body.modality !== "undefined" && typeof body.modality !== "string") {
return Response.json(
{ error: { message: "modality must be a string when provided", type: "validation_error" } },
{ status: 400 }
);
}
const modality = typeof body.modality === "string" && body.modality ? body.modality : undefined;
const modelIds = normalizeRequestedModelIds(searchParams, body);
if (modelIds.length === 0) {
return Response.json(
{
error: {
message: "modelId query param or body.modelIds is required",
type: "validation_error",
},
},
{ status: 400 }
);
}
for (const modelId of modelIds) {
const updatedModel = await updateCustomModel(provider, modelId, { isHidden: body.isHidden });
if (!updatedModel) {
mergeModelCompatOverride(provider, modelId, { isHidden: body.isHidden, modality });
}
}
const aliasChanges =
body.isHidden === true
? { removed: await deleteManagedAvailableModelAliases(provider, modelIds), assigned: [] }
: {
removed: [],
assigned: (
await syncManagedAvailableModelAliases(provider, modelIds, { pruneMissing: false })
).assignedAliases,
};
return Response.json({
ok: true,
updated: modelIds.length,
aliasChanges,
models: await getCustomModels(provider),
modelCompatOverrides: getModelCompatOverrides(provider),
});
} catch (error) {
console.error("Error patching provider models:", error);
return Response.json(
{ error: { message: "Failed to update provider models", type: "server_error" } },
{ status: 500 }
);
}
}
/**
* DELETE /api/provider-models?provider=<id>&model=<modelId>
*/
export async function DELETE(request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
try {
const { searchParams } = new URL(request.url);
const provider = searchParams.get("provider");
const modelId = searchParams.get("model");
const resetOverride = searchParams.get("resetOverride") === "true";
const resetEndpoints = searchParams.get("resetEndpoints") === "true";
if (!provider) {
return Response.json(
{
error: {
message: "provider query param is required",
type: "validation_error",
},
},
{ status: 400 }
);
}
// DELETE /api/provider-models?provider=<id>&all=true — clear all models
const all = searchParams.get("all");
if (all === "true") {
await replaceCustomModels(provider, [], { allowEmpty: true });
const syncedAvailableModelListsRemoved =
await deleteSyncedAvailableModelsForProvider(provider);
const removedAliases = await deleteManagedAvailableModelAliasesForProvider(provider);
return Response.json({
cleared: true,
syncedAvailableModelListsRemoved,
aliasChanges: { removed: removedAliases, assigned: [] },
});
}
if (!modelId) {
return Response.json(
{
error: {
message: "model query param is required (or use all=true)",
type: "validation_error",
},
},
{ status: 400 }
);
}
if (resetEndpoints) {
const restored = await resetModelEndpointOverride(provider, modelId);
if (!restored)
return Response.json(
{ error: { message: "No endpoint override to reset", type: "not_found" } },
{ status: 404 }
);
return Response.json({ restored: true, resetEndpoints: true });
}
// Resetting a user-owned overlay must never delete the same-id synced base.
// The normal delete action retains its existing behavior for a standalone
// synced row, while the detail-page reset control uses resetOverride=true.
const removedCustom = await removeCustomModel(provider, modelId);
const removedSynced =
removedCustom || resetOverride ? false : await removeSyncedAvailableModel(provider, modelId);
const removed = removedCustom || removedSynced;
if (resetOverride && removedCustom) {
removeModelContextOverride(provider, modelId);
const aliasChanges = await syncManagedAvailableModelAliases(provider, [modelId], {
pruneMissing: false,
});
return Response.json({
removed,
resetOverride: true,
aliasChanges,
});
}
const removedAliases = await deleteManagedAvailableModelAliases(provider, [modelId]);
return Response.json({ removed, aliasChanges: { removed: removedAliases, assigned: [] } });
} catch (error) {
console.error("Error removing provider model:", error);
return Response.json(
{ error: { message: "Failed to remove provider model", type: "server_error" } },
{ status: 500 }
);
}
}