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 { NextResponse } from "next/server";
import { getAuditRequestContext, logAuditEvent } from "@/lib/compliance/index";
import {
getProviderAuditTarget,
summarizeProviderConnectionForAudit,
} from "@/lib/compliance/providerAudit";
import {
createProviderConnection,
getProviderConnections,
getProviderNodeById,
isCloudEnabled,
} from "@/models";
import {
isAnthropicCompatibleProvider,
isOpenAICompatibleProvider,
} from "@/shared/constants/providers";
import { isManagedProviderConnectionId } from "@/lib/providers/catalog";
import { getConsistentMachineId } from "@/shared/utils/machineId";
import { resolveBulkNameCollisions } from "@/shared/utils/bulkApiKeyParser";
import { syncToCloud } from "@/lib/cloudSync";
import { bulkImportProviderSchema } from "@/shared/validation/schemas";
import { isValidationFailure, validateBody } from "@/shared/validation/helpers";
import {
normalizeProviderSpecificData,
sanitizeProviderSpecificDataForResponse,
} from "@/lib/providers/requestDefaults";
import { requireManagementAuth } from "@/lib/api/requireManagementAuth";
import { sanitizeErrorMessage } from "@omniroute/open-sse/utils/error";
import { validateProviderApiKey } from "@/lib/providers/validation";
import { getRequestPeerLocality } from "@/shared/utils/apiAuth";
import { getProxyForLevel } from "@/lib/db/settings";
import { resolveProxyForProvider } from "@/lib/db/proxies";
import { runWithProxyContext } from "@omniroute/open-sse/utils/proxyFetch.ts";
import { rejectRetiredCommonChatGptWebProvider } from "@/lib/providers/chatgptWebRetirementResponse";
type ImportEntry = {
provider: string;
name: string;
apiKey: string;
baseUrl?: string;
priority?: number;
};
/**
* Resolve the providerSpecificData base object for one entry's provider — mirrors the
* per-provider node resolution in POST /api/providers/bulk, plus an optional per-entry
* `baseUrl` override (the file-import format lets each row point at a different
* OpenAI/Anthropic-compatible endpoint, unlike the single-provider bulk-key route).
*/
async function resolveProviderSpecificData(
entry: ImportEntry
): Promise<Record<string, unknown> | null> {
let base: Record<string, unknown> | null = null;
if (isOpenAICompatibleProvider(entry.provider) || isAnthropicCompatibleProvider(entry.provider)) {
const node: any = await getProviderNodeById(entry.provider);
if (!node) return null;
base = {
prefix: node.prefix,
...(node.apiType ? { apiType: node.apiType } : {}),
baseUrl: entry.baseUrl || node.baseUrl,
nodeName: node.name,
...(node.chatPath ? { chatPath: node.chatPath } : {}),
...(node.modelsPath ? { modelsPath: node.modelsPath } : {}),
};
} else if (entry.baseUrl) {
base = { baseUrl: entry.baseUrl };
}
return normalizeProviderSpecificData(entry.provider, base) || base;
}
// Provider-existence check (moved out of the Zod schema so the client-reachable schema
// stays free of the server-only provider catalog — #6836; isManagedProviderConnectionId
// drags the server runtime into the browser/CLI bundle). Extracted as a helper so the
// per-row check adds no branches to importOneEntry's own complexity.
function isKnownImportProvider(provider: string): boolean {
return (
isManagedProviderConnectionId(provider) ||
isOpenAICompatibleProvider(provider) ||
isAnthropicCompatibleProvider(provider)
);
}
async function importOneEntry(
entry: ImportEntry,
validateKeys: boolean,
allowLocalSpawn: boolean
): Promise<{ created: Record<string, unknown> } | { error: string }> {
// Reject unknown providers per-row, preserving the partial-failure contract of /bulk.
if (!isKnownImportProvider(entry.provider)) {
return { error: "Unknown or unsupported provider" };
}
const providerSpecificData = await resolveProviderSpecificData(entry);
if (
(isOpenAICompatibleProvider(entry.provider) || isAnthropicCompatibleProvider(entry.provider)) &&
!providerSpecificData
) {
return { error: "Provider node not found" };
}
const proxyToUse = validateKeys
? (await resolveProxyForProvider(entry.provider)) ||
(await getProxyForLevel("provider", entry.provider)) ||
(await getProxyForLevel("global")) ||
null
: null;
let testStatus: "active" | "unknown" | "failed" = "unknown";
if (validateKeys) {
const probe = await runWithProxyContext(proxyToUse, () =>
validateProviderApiKey({
provider: entry.provider,
apiKey: entry.apiKey,
providerSpecificData: providerSpecificData || undefined,
// S-01 (#15159, #15766 shape): devin CLI-spawn fallback is loopback/LAN-only.
allowLocalSpawn,
})
);
testStatus = probe?.valid ? "active" : "failed";
}
const newConnection = await createProviderConnection({
provider: entry.provider,
authType: "apikey",
name: entry.name,
apiKey: entry.apiKey,
priority: entry.priority || 1,
globalPriority: null,
defaultModel: null,
providerSpecificData,
isActive: true,
testStatus,
});
const safe: Record<string, unknown> = { ...newConnection };
delete safe.apiKey;
if (safe.providerSpecificData) {
safe.providerSpecificData = sanitizeProviderSpecificDataForResponse(
safe.providerSpecificData as Record<string, unknown>
);
}
return { created: safe };
}
/**
* #2587 / #6836 — mirrors the guard in POST /api/providers/bulk: createProviderConnection
* upserts apikey connections BY NAME, so an imported row whose (provider, name) collides
* with an already-saved connection — or with an earlier row in the SAME import batch —
* would silently REPLACE that connection's apiKey/priority instead of inserting a new
* one, while the response still reported it as a fresh "created" success. Unlike /bulk
* (single provider per request), one import batch can span many DIFFERENT providers, so
* collisions are resolved per-provider: existing connection names are fetched once per
* distinct provider in the batch, then `resolveBulkNameCollisions` gap-fills a free
* "<name> <n>" suffix for every entry so each one reaches createProviderConnection as a
* genuine insert.
*/
async function resolveImportNameCollisions(entries: ImportEntry[]): Promise<ImportEntry[]> {
const indicesByProvider = new Map<string, number[]>();
entries.forEach((entry, index) => {
const indices = indicesByProvider.get(entry.provider) || [];
indices.push(index);
indicesByProvider.set(entry.provider, indices);
});
const resolved: ImportEntry[] = [...entries];
for (const [provider, indices] of indicesByProvider) {
const existingConnections = await getProviderConnections({ provider, authType: "apikey" });
const existingNames = existingConnections
.map((c) => (typeof c.name === "string" ? c.name : null))
.filter((n): n is string => !!n);
const providerEntries = indices.map((i) => ({ name: entries[i].name }));
const resolvedProviderEntries = resolveBulkNameCollisions(providerEntries, existingNames);
indices.forEach((originalIndex, i) => {
resolved[originalIndex] = {
...entries[originalIndex],
name: resolvedProviderEntries[i].name,
};
});
}
return resolved;
}
async function syncToCloudIfEnabled() {
try {
const cloudEnabled = await isCloudEnabled();
if (!cloudEnabled) return;
const machineId = await getConsistentMachineId();
await syncToCloud(machineId);
} catch (error) {
console.log("Error syncing providers to cloud:", error);
}
}
// POST /api/providers/import — create multiple provider connections from a parsed
// CSV/JSON file, where each row/entry may target a DIFFERENT provider (#6836).
// Partial-failure semantics identical to /api/providers/bulk: every entry succeeds or
// fails independently and the response always returns 200 with per-entry results.
export async function POST(request: Request) {
const authError = await requireManagementAuth(request);
if (authError) return authError;
const auditContext = getAuditRequestContext(request);
let body: unknown;
try {
body = await request.json();
} catch {
return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
}
const validation = validateBody(bulkImportProviderSchema, body);
if (isValidationFailure(validation)) {
return NextResponse.json({ error: validation.error }, { status: 400 });
}
const { entries, validateKeys } = validation.data;
for (const entry of entries) {
const retirementResponse = rejectRetiredCommonChatGptWebProvider(entry.provider);
if (retirementResponse) return retirementResponse;
}
const resolvedEntries = await resolveImportNameCollisions(entries);
const created: Array<Record<string, unknown>> = [];
const errors: Array<{ index: number; name: string; provider: string; message: string }> = [];
for (let i = 0; i < resolvedEntries.length; i++) {
const entry = resolvedEntries[i];
try {
const result = await importOneEntry(
entry,
!!validateKeys,
// S-01 (#15159, #15766 shape): devin CLI-spawn fallback is loopback/LAN-only.
getRequestPeerLocality(request) !== "remote"
);
if ("error" in result) {
errors.push({
index: i,
name: entry.name,
provider: entry.provider,
message: result.error,
});
continue;
}
created.push(result.created);
logAuditEvent({
action: "provider.credentials.created",
actor: "admin",
target: getProviderAuditTarget(result.created),
resourceType: "provider_credentials",
status: "success",
ipAddress: auditContext.ipAddress || undefined,
requestId: auditContext.requestId,
metadata: {
provider: entry.provider,
via: "import",
connection: summarizeProviderConnectionForAudit(result.created),
},
});
} catch (err) {
errors.push({
index: i,
name: entry.name,
provider: entry.provider,
message: sanitizeErrorMessage(err) || "Failed to create connection",
});
}
}
if (created.length > 0) {
await syncToCloudIfEnabled();
}
logAuditEvent({
action: "provider.credentials.bulk_created",
actor: "admin",
resourceType: "provider_credentials",
status: errors.length === entries.length ? "failure" : "success",
ipAddress: auditContext.ipAddress || undefined,
requestId: auditContext.requestId,
metadata: {
via: "import",
total: entries.length,
success: created.length,
failed: errors.length,
},
});
return NextResponse.json(
{
success: created.length,
failed: errors.length,
total: entries.length,
created,
errors,
},
{ status: 200 }
);
}