feat: Google Gemini image generation for project covers

Schema: - SystemSettings: geminiApiKey, geminiModel, imageProvider fields - imageProvider: "dalle" (default) or "gemini" Gemini Client (packages/api/src/gemini-client.ts): - Direct HTTP call to Gemini REST API with responseModalities: [TEXT, IMAGE] - Returns base64 data URL - Error parsing with user-friendly messages Router (project.ts): - generateCover: routes to DALL-E or Gemini based on imageProvider setting - New isImageGenConfigured query returning { configured, provider } Admin UI (SystemSettingsClient.tsx): - "Image Generation" section with provider radio buttons (DALL-E / Gemini) - Conditional fields: DALL-E config or Gemini API key + model - Separate save button for image settings Security: - geminiApiKey sanitized in audit logs (SENSITIVE_FIELDS) - API key stored server-side only, never sent to client Co-Authored-By: claude-flow <ruv@ruv.net>
2026-03-23 15:02:35 +01:00
parent 52d425043b
commit 502ecba9e9
6 changed files with 339 additions and 64 deletions
@@ -0,0 +1,94 @@
+type GeminiSettings = {
+  geminiApiKey?: string | null;
+  geminiModel?: string | null;
+};
+
+/** Returns true if the settings have a Gemini API key configured. */
+export function isGeminiConfigured(settings: GeminiSettings | null | undefined): boolean {
+  return !!settings?.geminiApiKey;
+}
+
+/**
+ * Generates an image using the Google Gemini API.
+ * @returns A base64 data URL of the generated image.
+ */
+export async function generateGeminiImage(
+  apiKey: string,
+  prompt: string,
+  model = "gemini-2.0-flash-preview-image-generation",
+): Promise<string> {
+  const fullPrompt = `Generate a professional, cinematic cover image for a 3D production project. ${prompt}`;
+
+  const response = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        contents: [{ parts: [{ text: fullPrompt }] }],
+        generationConfig: { responseModalities: ["TEXT", "IMAGE"] },
+      }),
+    },
+  );
+
+  if (!response.ok) {
+    const body = await response.text();
+    let msg = body;
+    try {
+      const parsed = JSON.parse(body) as { error?: { message?: string } };
+      if (parsed.error?.message) msg = parsed.error.message;
+    } catch {
+      /* keep raw */
+    }
+    throw new Error(`HTTP ${response.status}: ${msg}`);
+  }
+
+  const data = (await response.json()) as {
+    candidates?: Array<{
+      content?: {
+        parts?: Array<{
+          inlineData?: { data: string; mimeType: string };
+          text?: string;
+        }>;
+      };
+    }>;
+  };
+
+  const imagePart = data.candidates?.[0]?.content?.parts?.find(
+    (p) => p.inlineData,
+  );
+
+  if (!imagePart?.inlineData?.data) {
+    throw new Error("No image data returned from Gemini");
+  }
+
+  const base64 = imagePart.inlineData.data;
+  const mimeType = imagePart.inlineData.mimeType ?? "image/png";
+  return `data:${mimeType};base64,${base64}`;
+}
+
+/** Turns Gemini API errors into actionable human-readable messages. */
+export function parseGeminiError(err: unknown): string {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+
+  if (lower.includes("400") || lower.includes("invalid")) {
+    return "Invalid request — check the Gemini model name and prompt.";
+  }
+  if (lower.includes("401") || lower.includes("unauthorized") || lower.includes("api_key_invalid") || lower.includes("api key not valid")) {
+    return "Invalid API key — make sure you copied it correctly from Google AI Studio.";
+  }
+  if (lower.includes("403") || lower.includes("forbidden") || lower.includes("permission")) {
+    return "Access denied — your API key may not have permission to use image generation.";
+  }
+  if (lower.includes("404") || lower.includes("not found")) {
+    return "Model not found — verify the Gemini model name is correct.";
+  }
+  if (lower.includes("429") || lower.includes("rate limit") || lower.includes("quota")) {
+    return "Rate limit or quota exceeded — wait a moment and try again.";
+  }
+  if (lower.includes("econnrefused") || lower.includes("enotfound") || lower.includes("fetch failed")) {
+    return "Cannot reach the Gemini API — check your network connection.";
+  }
+  return msg.replace(/^Error: /, "").slice(0, 300);
+}
@@ -12,6 +12,7 @@ import { buildDynamicFieldWhereClauses } from "./custom-field-filters.js";
 import { loadProjectPlanningReadModel } from "./project-planning-read-model.js";
 import { adminProcedure, controllerProcedure, createTRPCRouter, managerProcedure, protectedProcedure, requirePermission } from "../trpc.js";
 import { createDalleClient, isDalleConfigured, parseAiError } from "../ai-client.js";
+import { generateGeminiImage, isGeminiConfigured, parseGeminiError } from "../gemini-client.js";
 import { invalidateDashboardCache } from "../lib/cache.js";
 import { dispatchWebhooks } from "../lib/webhook-dispatcher.js";

@@ -434,10 +435,14 @@ export const projectRouter = createTRPCRouter({
        where: { id: "singleton" },
      });

-      if (!isDalleConfigured(settings)) {
+      const imageProvider = settings?.imageProvider ?? "dalle";
+      const useGemini = imageProvider === "gemini" && isGeminiConfigured(settings);
+      const useDalle = imageProvider === "dalle" && isDalleConfigured(settings);
+
+      if (!useGemini && !useDalle) {
        throw new TRPCError({
          code: "PRECONDITION_FAILED",
-          message: "DALL-E is not configured. Set up the DALL-E deployment in Admin → Settings.",
+          message: "No image provider configured. Set up DALL-E or Gemini in Admin → Settings.",
        });
      }

@@ -447,36 +452,53 @@ export const projectRouter = createTRPCRouter({
        ? `${basePrompt} Additional direction: ${input.prompt}`
        : basePrompt;

-      const dalleClient = createDalleClient(settings!);
-      const model = settings!.aiProvider === "azure" ? settings!.azureDalleDeployment! : "dall-e-3";
+      let coverImageUrl: string;

-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      let response: any;
-      try {
-        response = await dalleClient.images.generate({
-          model,
-          prompt: finalPrompt,
-          size: "1024x1024",
-          n: 1,
-          response_format: "b64_json",
-        });
-      } catch (err) {
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: `DALL-E error: ${parseAiError(err)}`,
-        });
+      if (useGemini) {
+        try {
+          coverImageUrl = await generateGeminiImage(
+            settings!.geminiApiKey!,
+            finalPrompt,
+            settings!.geminiModel ?? undefined,
+          );
+        } catch (err) {
+          throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: `Gemini error: ${parseGeminiError(err)}`,
+          });
+        }
+      } else {
+        const dalleClient = createDalleClient(settings!);
+        const model = settings!.aiProvider === "azure" ? settings!.azureDalleDeployment! : "dall-e-3";
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let response: any;
+        try {
+          response = await dalleClient.images.generate({
+            model,
+            prompt: finalPrompt,
+            size: "1024x1024",
+            n: 1,
+            response_format: "b64_json",
+          });
+        } catch (err) {
+          throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: `DALL-E error: ${parseAiError(err)}`,
+          });
+        }
+
+        const b64 = response.data?.[0]?.b64_json;
+        if (!b64) {
+          throw new TRPCError({
+            code: "INTERNAL_SERVER_ERROR",
+            message: "No image data returned from DALL-E",
+          });
+        }
+
+        coverImageUrl = `data:image/png;base64,${b64}`;
      }

-      const b64 = response.data?.[0]?.b64_json;
-      if (!b64) {
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message: "No image data returned from DALL-E",
-        });
-      }
-
-      const coverImageUrl = `data:image/png;base64,${b64}`;
-
      await ctx.db.project.update({
        where: { id: input.projectId },
        data: { coverImageUrl },
@@ -552,11 +574,28 @@ export const projectRouter = createTRPCRouter({
      return { ok: true };
    }),

+  isImageGenConfigured: protectedProcedure
+    .query(async ({ ctx }) => {
+      const settings = await ctx.db.systemSettings.findUnique({
+        where: { id: "singleton" },
+      });
+      const imageProvider = settings?.imageProvider ?? "dalle";
+      const configured = imageProvider === "gemini"
+        ? isGeminiConfigured(settings)
+        : isDalleConfigured(settings);
+      return { configured, provider: imageProvider };
+    }),
+
+  /** @deprecated Use isImageGenConfigured instead */
  isDalleConfigured: protectedProcedure
    .query(async ({ ctx }) => {
      const settings = await ctx.db.systemSettings.findUnique({
        where: { id: "singleton" },
      });
-      return { configured: isDalleConfigured(settings) };
+      const imageProvider = settings?.imageProvider ?? "dalle";
+      const configured = imageProvider === "gemini"
+        ? isGeminiConfigured(settings)
+        : isDalleConfigured(settings);
+      return { configured };
    }),
 });
@@ -12,6 +12,7 @@ const SENSITIVE_FIELDS = new Set([
  "smtpPassword",
  "azureDalleApiKey",
  "anonymizationSeed",
+  "geminiApiKey",
 ]);

 export const settingsRouter = createTRPCRouter({
@@ -55,6 +56,11 @@ export const settingsRouter = createTRPCRouter({
      azureDalleDeployment: settings?.azureDalleDeployment ?? null,
      azureDalleEndpoint: settings?.azureDalleEndpoint ?? null,
      hasDalleApiKey: !!settings?.azureDalleApiKey,
+      // Gemini
+      geminiModel: settings?.geminiModel ?? "gemini-2.0-flash-preview-image-generation",
+      hasGeminiApiKey: !!settings?.geminiApiKey,
+      // Image provider
+      imageProvider: settings?.imageProvider ?? "dalle",
      // Vacation defaults
      vacationDefaultDays: settings?.vacationDefaultDays ?? 28,
      // Timeline
@@ -103,6 +109,11 @@ export const settingsRouter = createTRPCRouter({
        azureDalleDeployment: z.string().optional(),
        azureDalleEndpoint: z.string().url().optional().or(z.literal("")),
        azureDalleApiKey: z.string().optional(),
+        // Gemini image generation
+        geminiApiKey: z.string().optional(),
+        geminiModel: z.string().optional(),
+        // Image provider selection
+        imageProvider: z.enum(["dalle", "gemini"]).optional(),
        // Vacation
        vacationDefaultDays: z.number().int().min(0).max(365).optional(),
        // Timeline
@@ -155,6 +166,14 @@ export const settingsRouter = createTRPCRouter({
        data.azureDalleEndpoint = input.azureDalleEndpoint || null;
      if (input.azureDalleApiKey !== undefined)
        data.azureDalleApiKey = input.azureDalleApiKey || null;
+      // Gemini
+      if (input.geminiApiKey !== undefined)
+        data.geminiApiKey = input.geminiApiKey || null;
+      if (input.geminiModel !== undefined)
+        data.geminiModel = input.geminiModel || null;
+      // Image provider
+      if (input.imageProvider !== undefined)
+        data.imageProvider = input.imageProvider;
      // Vacation
      if (input.vacationDefaultDays !== undefined) data.vacationDefaultDays = input.vacationDefaultDays;
      // Timeline
@@ -1447,6 +1447,10 @@ model SystemSettings {
  azureDalleDeployment    String?  // e.g. "dall-e-3" — Azure DALL-E deployment name
  azureDalleEndpoint      String?  // Optional: separate endpoint for DALL-E (if different from chat)
  azureDalleApiKey        String?  // Optional: separate API key for DALL-E
+  // Gemini image generation
+  geminiApiKey            String?
+  geminiModel             String?  @default("gemini-2.0-flash-preview-image-generation")
+  imageProvider           String?  @default("dalle")  // "dalle" | "gemini"
  updatedAt               DateTime @updatedAt

  @@map("system_settings")