Skip to content

Email for professionals and teams

4.7 KB
Raw Blame
import { eq } from "drizzle-orm";
import { z } from "zod";
import { getDb } from "@/db";
import { agentJobs, agentSendApprovals, appSettings } from "@/db/schema";
import { getEnv } from "@/lib/cloudflare";
import { requireSessionUser } from "@/lib/api/auth";
import { isPrimaryAdmin } from "@/lib/auth/admin";
import { getAgentEnabled, getAgentProviderConfig, getAgentProviderPublicConfig, resolveAgentBaseUrl } from "@/lib/agent/provider";
import { AGENT_SETTINGS_ID } from "@/lib/agent/provider-constants";
import { parseAgentModelIds } from "@/lib/agent/model-ids";
import { hasValidSessionMutationOrigin } from "@/lib/auth/origin";

const providerSchema = z.object({
	provider: z.enum(["cloudflare", "compatible"]),
	preset: z.enum(["openai", "openrouter", "groq", "custom"]),
	baseUrl: z.string().max(500),
	apiKey: z.string().max(2_000).optional(),
	model: z.string().trim().min(1).max(5_000),
	rates: z.record(z.string(), z.object({ input: z.number().min(0).max(1_000_000).nullable(), output: z.number().min(0).max(1_000_000).nullable() })).optional(),
});
const enabledSchema = z.object({ enabled: z.boolean() });

async function authorize(request: Request) {
	const env = getEnv();
	const session = await requireSessionUser(env, request);
	if (session.error) return { env, error: session.error };
	if (!isPrimaryAdmin(session.user)) return { env, error: Response.json({ error: "Forbidden" }, { status: 403 }) };
	return { env, error: null };
}

export async function GET(request: Request) {
	const access = await authorize(request);
	if (access.error) return access.error;
	return Response.json({ config: await getAgentProviderPublicConfig(access.env), assistantEnabled: await getAgentEnabled(access.env), cloudflareAvailable: !!access.env.AI }, { headers: { "Cache-Control": "no-store" } });
}

export async function PUT(request: Request) {
	const access = await authorize(request);
	if (access.error) return access.error;
	if (!hasValidSessionMutationOrigin(request)) return Response.json({ error: "Invalid origin" }, { status: 403 });
	const body = await request.json().catch(() => null);
	const enabled = enabledSchema.safeParse(body);
	if (enabled.success && Object.keys(body as object).length === 1) {
		const db = getDb(access.env);
		await db.insert(appSettings).values({ id: AGENT_SETTINGS_ID, agentEnabled: enabled.data.enabled }).onConflictDoUpdate({ target: appSettings.id, set: { agentEnabled: enabled.data.enabled, updatedAt: new Date() } });
		if (!enabled.data.enabled) {
			await db.update(agentJobs).set({ status: "skipped", reason: "Assistant disabled" }).where(eq(agentJobs.status, "pending"));
			await db.update(agentSendApprovals).set({ status: "cancelled" }).where(eq(agentSendApprovals.status, "pending"));
		}
		return Response.json({ assistantEnabled: enabled.data.enabled }, { headers: { "Cache-Control": "no-store" } });
	}
	const parsed = providerSchema.safeParse(body);
	if (!parsed.success) return Response.json({ error: "Invalid provider settings" }, { status: 400 });
	const input = parsed.data;
	const modelIds = parseAgentModelIds(input.model);
	if (modelIds.length === 0 || modelIds.length > 20 || modelIds.some((model) => model.length > 200)) return Response.json({ error: "Choose 1 to 20 valid model IDs" }, { status: 400 });
	if (input.provider === "cloudflare" && !access.env.AI) return Response.json({ error: "Cloudflare Workers AI binding is unavailable" }, { status: 400 });
	let baseUrl: string | null = null;
	let apiKey: string | null = null;
	if (input.provider === "compatible") {
		try { baseUrl = resolveAgentBaseUrl(input.preset, input.baseUrl); }
		catch { return Response.json({ error: "Enter a valid HTTPS provider base URL" }, { status: 400 }); }
		const current = await getAgentProviderConfig(access.env);
		apiKey = input.apiKey?.trim() || (current.provider === "compatible" && current.preset === input.preset && current.baseUrl === baseUrl ? current.apiKey : "") || null;
		if (!apiKey) return Response.json({ error: "Enter an API key for this provider" }, { status: 400 });
	}
	const values = {
		agentProvider: input.provider,
		agentPreset: input.provider === "compatible" ? input.preset : null,
		agentBaseUrl: baseUrl,
		agentApiKey: apiKey,
		agentModel: modelIds.join(", "),
		agentModelRates: JSON.stringify(Object.fromEntries(modelIds.map((model) => [model, input.rates?.[model] ?? { input: null, output: null }]))),
		updatedAt: new Date(),
	};
	await getDb(access.env).insert(appSettings).values({ id: AGENT_SETTINGS_ID, ...values }).onConflictDoUpdate({ target: appSettings.id, set: values });
	return Response.json({ config: await getAgentProviderPublicConfig(access.env), assistantEnabled: await getAgentEnabled(access.env), cloudflareAvailable: !!access.env.AI }, { headers: { "Cache-Control": "no-store" } });
}