Skip to content

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

20.9 KB
Raw Blame
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 }
    );
  }
}