feat(image): implement OpenAI image generation; tighten setup scripts; restore strict linting

Author: Misbah-Engr

eslint.config.js

@@ -43,30 +43,7 @@ export default tseslint.config(
     },
   },
   {
-    // Relax strict rules for chat components/hooks and streaming route to allow pragmatic typing
-    files: [
-      "src/app/(general)/_components/chat/**/*.ts",
-      "src/app/(general)/_components/chat/**/*.tsx",
-  "src/app/(general)/_contexts/**/*.ts",
-  "src/app/(general)/_contexts/**/*.tsx",
-      "src/app/(general)/_hooks/**/*.ts",
-      "src/app/(general)/_hooks/**/*.tsx",
-      "src/app/api/chat/route.ts",
-      "src/server/api/routers/sync.ts",
-      "src/ai/image/**/*.ts",
-    ],
-    rules: {
-      "@typescript-eslint/no-explicit-any": "off",
-      "@typescript-eslint/no-unsafe-assignment": "off",
-      "@typescript-eslint/no-unsafe-member-access": "off",
-      "@typescript-eslint/no-unsafe-return": "off",
-      "@typescript-eslint/no-unsafe-call": "off",
-  "@typescript-eslint/no-unnecessary-type-assertion": "off",
-      "@typescript-eslint/prefer-optional-chain": "off",
-      "@typescript-eslint/no-floating-promises": "off",
-      "@typescript-eslint/no-misused-promises": "off",
-      "react-hooks/exhaustive-deps": "warn",
-    },
+    // Removed earlier broad rule relaxations to preserve full type safety.
   },
   {
     linterOptions: {

setup/steps/3_docker.ts

@@ -15,11 +15,7 @@ import {
 // Start Docker Compose services
 export function startDockerServices(): void {
   try {
-    // Allow skipping docker setup via env or CI
-    if (process.env.SKIP_DOCKER === "1" || process.env.SKIP_DOCKER === "true" || process.env.CI === "true") {
-      logInfo("Skipping Docker services setup (SKIP_DOCKER/CI detected)");
-      return;
-    }
+    // Opinionated: do not allow skipping; environment is expected to support required services.
 
     // Check if Docker is available
     const dockerCommand = checkDocker();
@@ -42,9 +38,7 @@ export function startDockerServices(): void {
     }
 
     if (!dockerDaemonRunning(dockerCommand)) {
-      logWarning(
-        `${dockerCommand} daemon is not running. Skipping Docker services. Start the daemon and rerun if needed.`,
-      );
+      logError(`${dockerCommand} daemon is not running. Start it and rerun setup.`);
       return;
     }
 

setup/steps/4_database.ts

@@ -13,22 +13,6 @@ import {
 
 export function runMigrations(): void {
   try {
-    // Allow skipping via env flags or CI
-    if (
-      process.env.SKIP_DB === "1" ||
-      process.env.SKIP_DB === "true" ||
-      // support both SKIP_DB_MIGRATIONS and SKIP_DB_MIGRATE spellings
-      process.env.SKIP_DB_MIGRATIONS === "1" ||
-      process.env.SKIP_DB_MIGRATIONS === "true" ||
-      process.env.SKIP_DB_MIGRATE === "1" ||
-      process.env.SKIP_DB_MIGRATE === "true" ||
-      process.env.CI === "true"
-    ) {
-      logInfo(
-        "Skipping database migrations (SKIP_DB/SKIP_DB_MIGRATIONS/SKIP_DB_MIGRATE/CI detected)",
-      );
-      return;
-    }
 
     // If no local env file, warn and skip to keep setup non-blocking
     const envPath = join(getProjectRoot(), ".env.local");
@@ -38,20 +22,28 @@ export function runMigrations(): void {
     }
 
     // If DATABASE_URL isn't configured, skip to avoid blocking in ephemeral/dev envs
+    let dbUrl: string | undefined;
     try {
       const envContents = readFileSync(envPath, "utf8");
       const dbUrlLine = envContents
         .split(/\r?\n/)
         .find((l) => /^\s*DATABASE_URL\s*=/.test(l) && !/^\s*#/.test(l));
-      const dbUrl = dbUrlLine?.split("=").slice(1).join("=").trim();
-      if (!dbUrl) {
-        logWarning(
-          "DATABASE_URL missing in .env.local. Skipping database migrations. Configure it to enable Prisma.",
-        );
-        return;
-      }
+      dbUrl = dbUrlLine?.split("=").slice(1).join("=").trim();
     } catch {
-      // If we can't read/parse for some reason, proceed; failures will be caught below
+      // ignore, will handle below
+    }
+
+    if (!dbUrl) {
+      logWarning(
+        "DATABASE_URL missing in .env.local. Skipping database migrations. Configure it to enable Prisma.",
+      );
+      return;
+    }
+
+    const isLocal = /localhost|127\.0\.0\.1/.test(dbUrl);
+    if (!isLocal) {
+      logInfo("Remote/non-local DATABASE_URL detected; assuming migrations handled elsewhere. Skipping.");
+      return;
     }
 
     // Attempt to run migrations (script loads env via dotenv)

src/ai/image/generate.ts

@@ -1,15 +1,47 @@
 import type { ImageModelProvider } from "./types";
+import { createOpenAI } from "@ai-sdk/openai"; // example provider (extend as needed)
+import { generateImage as sdkGenerateImage } from "ai";
 
-export type GeneratedImage = {
-  uint8Array: Uint8Array;
+// We intentionally do not redefine SDK return types; we adapt to what the SDK returns.
+export interface GeneratedImageResult {
+  url: string;
   mimeType: string;
-};
-
-export const generateImage = async (
-  _model: `${ImageModelProvider}:${string}`,
-  _prompt: string,
-): Promise<GeneratedImage> => {
-  throw new Error(
-    "Image generation is not configured in this build. Please set provider keys and implement a v5-compatible image generation path.",
-  );
-};
+  bytes?: Uint8Array;
+}
+
+// Basic provider routing; extend with other providers if needed.
+function getProvider(model: `${ImageModelProvider}:${string}`) {
+  const [provider] = model.split(":");
+  switch (provider) {
+    case "openai":
+      return createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    default:
+      throw new Error(`Unsupported image provider: ${provider}`);
+  }
+}
+
+export async function generateImage(
+  model: `${ImageModelProvider}:${string}`,
+  prompt: string,
+): Promise<GeneratedImageResult> {
+  const provider = getProvider(model);
+  // The v5 SDK generateImage returns an iterator/stream or object depending on provider; we assume a simple call pattern.
+  const { image } = await sdkGenerateImage({
+    model: provider.image(model.split(":")[1]!),
+    prompt,
+  });
+
+  if (!image) throw new Error("No image returned by provider");
+
+  // Normalized shape. Some providers may give URL directly, others raw bytes.
+  if (typeof image.url === "string") {
+    return { url: image.url, mimeType: image.mimeType ?? "image/png" };
+  }
+
+  if (image.bytes instanceof Uint8Array) {
+    // Caller is responsible for persisting bytes (we convert upstream where needed)
+    return { url: "", mimeType: image.mimeType ?? "image/png", bytes: image.bytes };
+  }
+
+  throw new Error("Unrecognized image response shape");
+}

src/ai/language/types.ts

@@ -1,4 +1,4 @@
-// ProviderMetadata removed in v5; use a generic record for providerOptions
+// ProviderMetadata: retained for compatibility; if the upstream SDK exposes a richer type, prefer importing it.
 export type ProviderMetadata = Record<string, unknown>;
 
 export enum LanguageModelCapability {

src/toolkits/toolkits/image/tools/generate/server.ts

@@ -4,7 +4,7 @@ import { put } from "@vercel/blob";
 import { api } from "@/trpc/server";
 import type { imageParameters } from "../../base";
 import type z from "zod";
-import { generateImage, type GeneratedImage } from "@/ai/image/generate";
+import { generateImage } from "@/ai/image/generate";
 
 export const generateToolConfigServer = (
   parameters: z.infer<typeof imageParameters>,
@@ -14,28 +14,27 @@ export const generateToolConfigServer = (
 > => {
   return {
     callback: async ({ prompt }) => {
-  const image: GeneratedImage = await generateImage(parameters.model, prompt);
+      const result = await generateImage(parameters.model, prompt);
+      if (!result) throw new Error("No image generated");
 
-      if (!image) {
-        console.error("No image generated");
-        throw new Error("No image generated");
+      // If we already have a remote URL, persist metadata only.
+      if (result.url) {
+        await api.images.createImage({
+          url: result.url,
+          contentType: result.mimeType,
+        });
+        return { url: result.url };
       }
 
+      if (!result.bytes) throw new Error("Image result missing bytes");
       const imageId = crypto.randomUUID();
+      const ext = result.mimeType.split("/")[1] || "png";
+      const fileName = `images/${imageId}.${ext}`;
+      const file = new File([result.bytes], fileName, { type: result.mimeType });
 
-  const fileName = `images/${imageId}.${image.mimeType.split("/")[1]}`;
-  const file = new File([image.uint8Array], fileName, { type: image.mimeType });
-
-      const { url: imageUrl } = await put(file.name, file, {
-        access: "public",
-      });
-
-      await api.images.createImage({
-        url: imageUrl,
-        contentType: image.mimeType,
-      });
-
-      return { url: imageUrl };
+      const { url } = await put(file.name, file, { access: "public" });
+      await api.images.createImage({ url, contentType: result.mimeType });
+      return { url };
     },
   };
 };