From aa300d2a713bf7a7bea2da1b347c936d4d53f4a0 Mon Sep 17 00:00:00 2001
From: moose-lab <mooseindiehacker@gmail.com>
Date: Mon, 8 Jun 2026 13:23:53 +0800
Subject: [PATCH 1/2] feat: add OpenAI generation provider

---
 .env.example                             |   4 +
 README.md                                |  25 +--
 api/generations.test.ts                  |  30 ++--
 api/generations.ts                       |   4 +-
 src/App.test.tsx                         |  20 +--
 src/components/landing/HeroSection.tsx   |   4 +-
 src/server/generation/generation.test.ts | 187 ++++++++++++++++++++++-
 src/server/generation/image-generator.ts | 118 +++++++++++++-
 src/server/generation/llm.ts             | 158 ++++++++++++++++++-
 src/server/generation/orchestrator.ts    |  99 +++++++++---
 src/server/generation/prompt.ts          |  38 ++++-
 src/server/generation/types.ts           |   2 +-
 12 files changed, 623 insertions(+), 66 deletions(-)

diff --git a/.env.example b/.env.example
index 6bf7704..9203a2d 100644
--- a/.env.example
+++ b/.env.example
@@ -1,5 +1,9 @@
 # Server-side only. Never expose real API keys in browser code.
 OPENAI_API_KEY=
+# Optional override for OpenAI-compatible API gateways. Leave blank for https://api.openai.com/v1.
+OPENAI_BASE_URL=
+# Optional fallback provider for /api/generations when provider is set to "wavespeed".
+WAVESPEED_API_KEY=
 DATABASE_URL=
 BETTER_AUTH_SECRET=
 BETTER_AUTH_URL=http://localhost:5173
diff --git a/README.md b/README.md
index a1b268f..a655778 100644
--- a/README.md
+++ b/README.md
@@ -83,10 +83,12 @@ src/
   server/
     auth.ts               Better Auth configuration
     db/                   Neon Drizzle client and auth schema
+    generation/           GitHub source lookup, launch brief orchestration, and image provider adapters
   styles/
     app.css               Responsive product UI
 api/
   auth/[...all].ts        Vercel Function mounted at /api/auth/*
+  generations.ts          Vercel Function mounted at /api/generations
 drizzle/
   *.sql                   Database migrations
 public/
@@ -114,6 +116,10 @@ Secrets belong on the server, not in browser code:
 
 ```env
 OPENAI_API_KEY=
+# Optional OpenAI-compatible gateway override. Leave blank for the official OpenAI API.
+OPENAI_BASE_URL=
+# Optional fallback provider key when /api/generations uses provider="wavespeed".
+WAVESPEED_API_KEY=
 DATABASE_URL=
 BETTER_AUTH_SECRET=
 BETTER_AUTH_URL=
@@ -147,14 +153,18 @@ http://localhost:5173/api/auth/callback/google
 https://your-domain.example/api/auth/callback/google
 ```
 
-For live generation, add a Node API layer or Vercel serverless route that:
+## Live Generation API
 
-1. fetches GitHub README / metadata / optional PDF context
-2. calls the copy model
-3. calls the image model
-4. stores a manifest with copy, prompt, image path, model settings, and output preset
+`POST /api/generations` runs the server-side launch-card workflow:
 
-The current app keeps the core workflow deterministic and client-safe.
+1. fetches GitHub repository metadata and README content, with deterministic fallback data for failed source lookups
+2. calls OpenAI Responses for repository analysis and launch planning when `provider` is `openai`
+3. calls OpenAI Images for the marketing card render and returns `outputs[locale].imageUrl` for browser preview
+4. writes prompt, image, quality report, and manifest artifacts under the server output root
+
+The Hero generator sends `provider: "openai"` by default and requires `OPENAI_API_KEY` in server runtime configuration. The API still accepts `provider: "mock"` for tests and `provider: "wavespeed"` for the existing Wavespeed-compatible path.
+
+ChatGPT OAuth is not used for this backend path. ChatGPT Actions OAuth authenticates ChatGPT to a third-party action API; QuickFork's own web backend calls OpenAI directly with a server-side API key.
 
 ## Local Development
 
@@ -193,10 +203,7 @@ VERCEL_PROJECT_ID=
 
 ## Roadmap
 
-- Fetch GitHub README and repository metadata automatically.
 - Add PDF upload and extraction for paper-style repositories.
-- Add server-side OpenAI generation using `OPENAI_API_KEY`.
-- Save generation manifests for repeatable publishing.
 - Export README banners, slide images, and social cards as separate assets.
 - Add project pages for public showcases.
 
diff --git a/api/generations.test.ts b/api/generations.test.ts
index 41fa58a..d41db17 100644
--- a/api/generations.test.ts
+++ b/api/generations.test.ts
@@ -9,22 +9,22 @@ describe("/api/generations input contract", () => {
         repoUrl: " https://github.com/QwenLM/FlashQLA ",
         locales: ["en", "zh"],
         preset: "4:3",
-        provider: "mock",
+        provider: "openai",
         imageQuality: "low",
         models: {
-          llm: "openai/gpt-5.5",
-          image: "openai/gpt-image-2/text-to-image",
+          llm: "gpt-5.5",
+          image: "gpt-image-2",
         },
       }),
     ).toMatchObject({
       repoUrl: "https://github.com/QwenLM/FlashQLA",
       locales: ["en", "zh"],
       preset: "4:3",
-      provider: "mock",
+      provider: "openai",
       imageQuality: "low",
       models: {
-        llm: "openai/gpt-5.5",
-        image: "openai/gpt-image-2/text-to-image",
+        llm: "gpt-5.5",
+        image: "gpt-image-2",
       },
     });
   });
@@ -60,12 +60,24 @@ describe("/api/generations input contract", () => {
     ).toThrow(/locales/i);
   });
 
-  it("uses the production provider requirement in validation errors", () => {
-    expect(() =>
+  it("accepts direct OpenAI and Wavespeed providers while rejecting unknown providers", () => {
+    expect(
       normalizeCreateGenerationInput({
         repoUrl: "https://github.com/QwenLM/FlashQLA",
         provider: "openai",
+      }).provider,
+    ).toBe("openai");
+    expect(
+      normalizeCreateGenerationInput({
+        repoUrl: "https://github.com/QwenLM/FlashQLA",
+        provider: "wavespeed",
+      }).provider,
+    ).toBe("wavespeed");
+    expect(() =>
+      normalizeCreateGenerationInput({
+        repoUrl: "https://github.com/QwenLM/FlashQLA",
+        provider: "chatgpt-oauth",
       }),
-    ).toThrow("provider must be wavespeed.");
+    ).toThrow("provider must be openai, wavespeed, or mock.");
   });
 });
diff --git a/api/generations.ts b/api/generations.ts
index 792ac43..ac4a5b1 100644
--- a/api/generations.ts
+++ b/api/generations.ts
@@ -18,7 +18,7 @@ const presetValues = [
   "16:9",
   "21:9",
 ] as const;
-const providerValues = ["mock", "wavespeed"] as const;
+const providerValues = ["mock", "openai", "wavespeed"] as const;
 const qualityValues = ["low"] as const;
 
 function sendJson(res: ServerResponse, statusCode: number, body: unknown) {
@@ -80,7 +80,7 @@ export function normalizeCreateGenerationInput(body: unknown): CreateGenerationI
     throw new GenerationError("VALIDATION_ERROR", "preset is not supported.");
   }
   if (value.provider !== undefined && !isOneOf(value.provider, providerValues)) {
-    throw new GenerationError("VALIDATION_ERROR", "provider must be wavespeed.");
+    throw new GenerationError("VALIDATION_ERROR", "provider must be openai, wavespeed, or mock.");
   }
   if (value.imageQuality !== undefined && !isOneOf(value.imageQuality, qualityValues)) {
     throw new GenerationError("VALIDATION_ERROR", "imageQuality must be low.");
diff --git a/src/App.test.tsx b/src/App.test.tsx
index fd77503..5ac3847 100644
--- a/src/App.test.tsx
+++ b/src/App.test.tsx
@@ -1357,18 +1357,18 @@ describe("App", () => {
             en: {
               promptPath: "output/project-launch/qwenlm-flashqla/en/marketing_card_prompt.txt",
               imagePath: "output/project-launch/qwenlm-flashqla/en/marketing-card.png",
-              imageUrl: "https://wavespeed.ai/generated/qwenlm-flashqla.png",
+              imageUrl: "data:image/png;base64,cXdlbmxtLWZsYXNocWxh",
               qualityReportPath: "output/project-launch/qwenlm-flashqla/en/quality-report.json",
             },
           },
           stages: [
             { id: "repo", label: "Repository source", status: "completed" },
-            { id: "readme", label: "GPT5.5 README analysis", status: "completed", model: "openai/gpt-5.5" },
-            { id: "image", label: "gpt-image-2 render", status: "completed", model: "openai/gpt-image-2/text-to-image" },
+            { id: "readme", label: "OpenAI README analysis", status: "completed", model: "gpt-5.5" },
+            { id: "image", label: "gpt-image-2 render", status: "completed", model: "gpt-image-2" },
           ],
           modelCalls: [
-            { provider: "wavespeed", model: "openai/gpt-5.5", purpose: "readme_analysis", status: "completed" },
-            { provider: "wavespeed", model: "openai/gpt-image-2/text-to-image", purpose: "image_generation", status: "completed" },
+            { provider: "openai", model: "gpt-5.5", purpose: "readme_analysis", status: "completed" },
+            { provider: "openai", model: "gpt-image-2", purpose: "image_generation", status: "completed" },
           ],
           launchBrief: {
             summary: "CUDA kernels for faster attention inference.",
@@ -1562,19 +1562,19 @@ describe("App", () => {
       repoUrl: "https://github.com/QwenLM/FlashQLA",
       locales: ["en"],
       preset: "4:3",
-      provider: "wavespeed",
+      provider: "openai",
       imageQuality: "low",
     });
     expect(await screen.findByText(/generated gen_qwenlm_flashqla_test/i)).toBeInTheDocument();
     const previewImage = await within(form).findByRole("img", { name: /qwenlm\/flashqla launch card/i });
     const controls = form.querySelector(".referenceControls");
-    expect(previewImage).toHaveAttribute("src", "https://wavespeed.ai/generated/qwenlm-flashqla.png");
-    expect(previewImage.closest(".generationPreview")).toHaveAccessibleName("Generated Wavespeed image result");
+    expect(previewImage).toHaveAttribute("src", "data:image/png;base64,cXdlbmxtLWZsYXNocWxh");
+    expect(previewImage.closest(".generationPreview")).toHaveAccessibleName("Generated OpenAI image result");
     expect(controls).not.toBeNull();
     expect((controls?.compareDocumentPosition(previewImage) ?? 0) & Node.DOCUMENT_POSITION_FOLLOWING).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
     expect(within(form).getByRole("link", { name: /download generated image/i })).toHaveAttribute(
       "href",
-      "https://wavespeed.ai/generated/qwenlm-flashqla.png",
+      "data:image/png;base64,cXdlbmxtLWZsYXNocWxh",
     );
     const briefRegion = await screen.findByRole("region", { name: /free repo launch brief/i });
     expect(within(briefRegion).getByText(/AI project builders, open-source maintainers/i)).toBeInTheDocument();
@@ -1733,7 +1733,7 @@ describe("App", () => {
     const previewDialog = await screen.findByRole("dialog", { name: /generated image preview/i });
     expect(within(previewDialog).getByRole("img", { name: /qwenlm\/flashqla launch card/i })).toHaveAttribute(
       "src",
-      "https://wavespeed.ai/generated/qwenlm-flashqla.png",
+      "data:image/png;base64,cXdlbmxtLWZsYXNocWxh",
     );
     expect(within(previewDialog).getByRole("link", { name: /download generated image/i })).toHaveAttribute(
       "download",
diff --git a/src/components/landing/HeroSection.tsx b/src/components/landing/HeroSection.tsx
index a04f7c1..da54c95 100644
--- a/src/components/landing/HeroSection.tsx
+++ b/src/components/landing/HeroSection.tsx
@@ -208,7 +208,7 @@ async function createGeneration(input: {
       repoUrl: input.repoUrl,
       locales: input.locales,
       preset: input.preset,
-      provider: "wavespeed",
+      provider: "openai",
       imageQuality: input.imageQuality,
     }),
   });
@@ -399,7 +399,7 @@ function ProjectLaunchInputPanel() {
           </label>
         </div>
         {generatedImageUrl ? (
-          <figure className="generationPreview" aria-label="Generated Wavespeed image result">
+          <figure className="generationPreview" aria-label="Generated OpenAI image result">
             <button
               aria-label="Open generated image preview"
               className="generationPreviewButton"
diff --git a/src/server/generation/generation.test.ts b/src/server/generation/generation.test.ts
index 6d55a37..d185b12 100644
--- a/src/server/generation/generation.test.ts
+++ b/src/server/generation/generation.test.ts
@@ -7,15 +7,19 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import {
   createMockLlmAdapter,
   DEFAULT_GENERATION_MODELS,
+  OPENAI_API_KEY_ENV,
+  OPENAI_BASE_URL_ENV,
+  OPENAI_RESPONSES_URL,
   WAVESPEED_API_KEY_ENV,
+  buildOpenAIResponsesRequest,
   buildWavespeedChatCompletionRequest,
 } from "./llm";
 import { resolveBrandAssets, storeReferenceAsset } from "./assets";
 import { buildProjectBrief } from "./brief";
 import { buildLayoutSpec, buildLocalizedCopies } from "./copy";
-import { generateWavespeedImage } from "./image-generator";
+import { generateOpenAIImage, generateWavespeedImage } from "./image-generator";
 import { runProjectLaunchGeneration } from "./orchestrator";
-import { buildImagePrompt, buildWavespeedImageRequest, imageAspectRatioForPreset, imageSizeForPreset } from "./prompt";
+import { OPENAI_IMAGE_ENDPOINT, buildImagePrompt, buildOpenAIImageRequest, buildWavespeedImageRequest, imageAspectRatioForPreset, imageSizeForPreset } from "./prompt";
 import { inspectMarketingCard } from "./quality";
 import { extractReadmeContext } from "./readme";
 import { fetchGitHubRepoMetadata, fetchRepositoryReadme, resolveRepositorySource } from "./repository-source";
@@ -72,6 +76,8 @@ const openDesignMetadata = {
 describe("project launch generation backend", () => {
   afterEach(() => {
     vi.unstubAllGlobals();
+    delete process.env.OPENAI_API_KEY;
+    delete process.env.OPENAI_BASE_URL;
     delete process.env.WAVESPEED_API_KEY;
     delete process.env.VERCEL;
   });
@@ -131,6 +137,45 @@ describe("project launch generation backend", () => {
     expect(JSON.stringify(request)).not.toContain("YOUR_API_KEY");
   });
 
+  it("builds the OpenAI Responses request without persisting credentials", () => {
+    const request = buildOpenAIResponsesRequest({
+      model: "gpt-5.5",
+      instructions: "Read this README and return project signals.",
+      input: JSON.stringify({ repo: "QwenLM/FlashQLA" }),
+      temperature: 0.2,
+    });
+
+    expect(OPENAI_API_KEY_ENV).toBe("OPENAI_API_KEY");
+    expect(request.url).toBe("https://api.openai.com/v1/responses");
+    expect(request.body).toMatchObject({
+      model: "gpt-5.5",
+      instructions: "Read this README and return project signals.",
+      input: expect.stringContaining("QwenLM/FlashQLA"),
+      temperature: 0.2,
+    });
+    expect(JSON.stringify(request)).not.toContain("test-openai-key");
+  });
+
+  it("uses the optional OpenAI-compatible base URL for text and image requests", () => {
+    process.env[OPENAI_BASE_URL_ENV] = "https://gateway.example.test/openai/v1/";
+
+    expect(
+      buildOpenAIResponsesRequest({
+        model: "gpt-5.5",
+        instructions: "Analyze.",
+        input: "README",
+      }).url,
+    ).toBe("https://gateway.example.test/openai/v1/responses");
+    expect(
+      buildOpenAIImageRequest({
+        model: "gpt-image-2",
+        prompt: "Create a launch card",
+        preset: "3:2",
+        quality: "low",
+      }).url,
+    ).toBe("https://gateway.example.test/openai/v1/images/generations");
+  });
+
   it("normalizes copied Wavespeed API keys before writing request headers", async () => {
     process.env.WAVESPEED_API_KEY = "“test-key”";
     const fetchMock = vi.fn(async (_url: string | URL | Request, _init?: RequestInit) =>
@@ -153,6 +198,29 @@ describe("project launch generation backend", () => {
     });
   });
 
+  it("normalizes copied OpenAI API keys before writing request headers", async () => {
+    process.env.OPENAI_API_KEY = "Bearer “test-openai-key”";
+    const fetchMock = vi.fn(async (_url: string | URL | Request, _init?: RequestInit) =>
+      new Response(JSON.stringify({ output_text: "ok" }), {
+        headers: { "Content-Type": "application/json" },
+        status: 200,
+      }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await import("./llm").then(({ callOpenAIResponses }) =>
+      callOpenAIResponses({
+        instructions: "Analyze the repository.",
+        input: "README",
+      }),
+    );
+
+    const firstRequest = fetchMock.mock.calls[0]?.[1];
+    expect(firstRequest?.headers).toMatchObject({
+      Authorization: "Bearer test-openai-key",
+    });
+  });
+
   it("normalizes GitHub repository URLs", () => {
     expect(parseGitHubRepositoryUrl("https://github.com/nexu-io/open-design")).toEqual({
       owner: "nexu-io",
@@ -759,6 +827,26 @@ describe("project launch generation backend", () => {
     });
   });
 
+  it("builds the OpenAI image request from the prompt contract", () => {
+    const imageRequest = buildOpenAIImageRequest({
+      model: "gpt-image-2",
+      prompt: "Create a launch card",
+      preset: "16:9",
+      quality: "low",
+    });
+
+    expect(imageRequest.url).toBe("https://api.openai.com/v1/images/generations");
+    expect(imageRequest.model).toBe("gpt-image-2");
+    expect(imageRequest.body).toEqual({
+      model: "gpt-image-2",
+      prompt: "Create a launch card",
+      size: "1536x1024",
+      quality: "low",
+      n: 1,
+      output_format: "png",
+    });
+  });
+
   it("builds an image prompt with source-backed identity rules and exact text slots", () => {
     const repo = parseGitHubRepositoryUrl("https://github.com/nexu-io/open-design");
     const readme = extractReadmeContext(openDesignReadme, repo, openDesignMetadata);
@@ -922,6 +1010,101 @@ describe("project launch generation backend", () => {
     }
   });
 
+  it("writes OpenAI image b64 results and returns a browser-renderable data URL", async () => {
+    const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-openai-image-"));
+    process.env.OPENAI_API_KEY = "test-openai-key";
+
+    try {
+      const result = await generateOpenAIImage(outputRoot, "en", {
+        model: "gpt-image-2",
+        size: "1536x1024",
+        quality: "low",
+        prompt: "Create a launch card with exact text.",
+        referencedAssets: [],
+      }, {
+        preset: "3:2",
+        fetchImpl: vi.fn(async () =>
+          new Response(JSON.stringify({ data: [{ b64_json: Buffer.from("fake-png").toString("base64") }] }), {
+            headers: { "Content-Type": "application/json" },
+            status: 200,
+          }),
+        ),
+      });
+
+      expect(result.status).toBe("completed");
+      expect(result.provider).toBe("openai");
+      expect(result.imageUrl).toBe(`data:image/png;base64,${Buffer.from("fake-png").toString("base64")}`);
+      await expect(readFile(result.promptPath, "utf8")).resolves.toContain("Create a launch card with exact text.");
+      await expect(readFile(result.imagePath, "utf8")).resolves.toBe("fake-png");
+    } finally {
+      await rm(outputRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("calls direct OpenAI Responses and Images APIs when provider is openai", async () => {
+    const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-openai-generation-"));
+    process.env.OPENAI_API_KEY = "test-openai-key";
+    const fetchMock = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+      const endpoint = String(url);
+      const headers = init?.headers as Record<string, string>;
+      expect(headers.Authorization).toBe("Bearer test-openai-key");
+      if (endpoint === OPENAI_RESPONSES_URL) {
+        return new Response(JSON.stringify({ output_text: "Use deterministic project evidence from the README." }), {
+          headers: { "Content-Type": "application/json" },
+          status: 200,
+        });
+      }
+      if (endpoint === OPENAI_IMAGE_ENDPOINT) {
+        expect(JSON.parse(String(init?.body))).toMatchObject({
+          model: "gpt-image-2",
+          prompt: expect.stringContaining("Asset type:"),
+          size: "1536x1024",
+          quality: "low",
+          output_format: "png",
+        });
+        return new Response(JSON.stringify({ data: [{ b64_json: Buffer.from("openai-card").toString("base64") }] }), {
+          headers: { "Content-Type": "application/json" },
+          status: 200,
+        });
+      }
+      throw new Error(`Unexpected fetch: ${endpoint}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const result = await runProjectLaunchGeneration({
+        repoUrl: "https://github.com/QwenLM/FlashQLA",
+        locales: ["en"],
+        provider: "openai",
+        preset: "16:9",
+        imageQuality: "low",
+        outputRoot,
+        mock: {
+          readmeMarkdown: openDesignReadme,
+        },
+      });
+
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+      expect(fetchMock.mock.calls.map((call) => String(call[0]))).toEqual([
+        "https://api.openai.com/v1/responses",
+        "https://api.openai.com/v1/responses",
+        "https://api.openai.com/v1/images/generations",
+      ]);
+      expect(result.modelConfig).toEqual({
+        llm: "gpt-5.5",
+        image: "gpt-image-2",
+      });
+      expect(result.modelCalls).toMatchObject([
+        { provider: "openai", model: "gpt-5.5", endpoint: "https://api.openai.com/v1/responses", purpose: "readme_analysis", status: "completed" },
+        { provider: "openai", model: "gpt-5.5", endpoint: "https://api.openai.com/v1/responses", purpose: "launch_plan", status: "completed" },
+        { provider: "openai", model: "gpt-image-2", endpoint: "https://api.openai.com/v1/images/generations", purpose: "image_generation", status: "completed" },
+      ]);
+      expect(result.outputs.en.imageUrl).toMatch(/^data:image\/png;base64,/);
+    } finally {
+      await rm(outputRoot, { recursive: true, force: true });
+    }
+  });
+
   it("calls Wavespeed GPT5.5 and gpt-image-2 when provider is wavespeed", async () => {
     const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-wavespeed-generation-"));
     process.env.WAVESPEED_API_KEY = "test-wavespeed-key";
diff --git a/src/server/generation/image-generator.ts b/src/server/generation/image-generator.ts
index cf8cc7f..35e998c 100644
--- a/src/server/generation/image-generator.ts
+++ b/src/server/generation/image-generator.ts
@@ -2,8 +2,8 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 import type { GeneratedImageResult, ImagePromptResult, LocaleCode } from "./types.js";
-import { WAVESPEED_API_KEY_ENV, normalizeWavespeedApiKey } from "./llm.js";
-import { WAVESPEED_PREDICTIONS_ENDPOINT, buildWavespeedImageRequest } from "./prompt.js";
+import { OPENAI_API_KEY_ENV, WAVESPEED_API_KEY_ENV, normalizeOpenAIApiKey, normalizeWavespeedApiKey } from "./llm.js";
+import { WAVESPEED_PREDICTIONS_ENDPOINT, buildOpenAIImageRequest, buildWavespeedImageRequest } from "./prompt.js";
 
 const WAVESPEED_IMAGE_POLL_INTERVAL_MS = 1000;
 const WAVESPEED_IMAGE_MAX_POLLS = 120;
@@ -19,6 +19,14 @@ type WavespeedImageResponse = {
   error?: unknown;
 };
 
+type OpenAIImageResponse = {
+  data?: Array<{
+    b64_json?: unknown;
+    url?: unknown;
+  }>;
+  error?: unknown;
+};
+
 export async function generateMockImage(localeDir: string, locale: LocaleCode, prompt: ImagePromptResult): Promise<GeneratedImageResult> {
   await mkdir(localeDir, { recursive: true });
   const promptPath = join(localeDir, "marketing_card_prompt.txt");
@@ -37,6 +45,89 @@ export async function generateMockImage(localeDir: string, locale: LocaleCode, p
   };
 }
 
+export async function generateOpenAIImage(
+  localeDir: string,
+  locale: LocaleCode,
+  prompt: ImagePromptResult,
+  input: {
+    preset: Parameters<typeof buildOpenAIImageRequest>[0]["preset"];
+    apiKey?: string;
+    fetchImpl?: typeof fetch;
+  },
+): Promise<GeneratedImageResult> {
+  const apiKey = input.apiKey ?? process.env[OPENAI_API_KEY_ENV];
+  if (!apiKey) {
+    throw new Error(`${OPENAI_API_KEY_ENV} is required to call OpenAI image generation.`);
+  }
+  const normalizedApiKey = normalizeOpenAIApiKey(apiKey);
+
+  await mkdir(localeDir, { recursive: true });
+  const promptPath = join(localeDir, "marketing_card_prompt.txt");
+  const imagePath = join(localeDir, "marketing-card.png");
+  await writeFile(promptPath, prompt.prompt, "utf8");
+
+  const request = buildOpenAIImageRequest({
+    model: prompt.model,
+    prompt: prompt.prompt,
+    preset: input.preset,
+    quality: prompt.quality,
+  });
+  const response = await (input.fetchImpl ?? fetch)(request.url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${normalizedApiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(request.body),
+  });
+  if (!response.ok) {
+    return writeFailedOpenAIImage({
+      imagePath,
+      prompt,
+      promptPath,
+      model: request.model,
+      message: `OpenAI image generation failed with ${response.status}.`,
+    });
+  }
+
+  const body = (await response.json()) as OpenAIImageResponse;
+  const firstImage = body.data?.[0];
+  if (typeof firstImage?.b64_json === "string" && firstImage.b64_json.trim()) {
+    await writeFile(imagePath, Buffer.from(firstImage.b64_json, "base64"));
+    return {
+      provider: "openai",
+      model: request.model,
+      status: "completed",
+      imagePath,
+      imageUrl: `data:image/png;base64,${firstImage.b64_json}`,
+      promptPath,
+      assetPaths: prompt.referencedAssets.map((asset) => asset.localPath),
+      warnings: [],
+    };
+  }
+  if (typeof firstImage?.url === "string" && firstImage.url.trim()) {
+    await writeFile(imagePath, `OpenAI image URL\n${firstImage.url}\n`, "utf8");
+    return {
+      provider: "openai",
+      model: request.model,
+      status: "completed",
+      imagePath,
+      imageUrl: firstImage.url,
+      promptPath,
+      assetPaths: prompt.referencedAssets.map((asset) => asset.localPath),
+      warnings: ["Stored the OpenAI output URL in the image artifact placeholder. Replace with binary download when production storage is selected."],
+    };
+  }
+
+  return writeFailedOpenAIImage({
+    imagePath,
+    prompt,
+    promptPath,
+    model: request.model,
+    message: `OpenAI image generation returned no image for ${locale}. error=${formatProviderError(body.error)}`,
+  });
+}
+
 export async function generateWavespeedImage(
   localeDir: string,
   locale: LocaleCode,
@@ -109,7 +200,7 @@ export async function generateWavespeedImage(
         prompt,
         promptPath,
         model: request.model,
-        message: `Wavespeed image generation failed for ${locale}. id=${body.id ?? "unknown"} error=${formatWavespeedError(body.error)}`,
+        message: `Wavespeed image generation failed for ${locale}. id=${body.id ?? "unknown"} error=${formatProviderError(body.error)}`,
       });
     }
     return writeFailedWavespeedImage({
@@ -154,6 +245,25 @@ async function writeFailedWavespeedImage(input: {
   };
 }
 
+async function writeFailedOpenAIImage(input: {
+  imagePath: string;
+  prompt: ImagePromptResult;
+  promptPath: string;
+  model: string;
+  message: string;
+}): Promise<GeneratedImageResult> {
+  await writeFile(input.imagePath, `OpenAI image generation failed\n${input.message}\n`, "utf8");
+  return {
+    provider: "openai",
+    model: input.model,
+    status: "failed",
+    imagePath: input.imagePath,
+    promptPath: input.promptPath,
+    assetPaths: input.prompt.referencedAssets.map((asset) => asset.localPath),
+    warnings: [input.message],
+  };
+}
+
 function imageResultUrls(response: WavespeedImageResponse) {
   const urls = response.urls ?? {};
   const preferred = urls.get ?? urls.result;
@@ -214,7 +324,7 @@ function normalizeWavespeedImageResponse(response: WavespeedImageResponse): Wave
   return response;
 }
 
-function formatWavespeedError(error: unknown) {
+function formatProviderError(error: unknown) {
   if (typeof error === "string" && error.trim()) return error;
   if (error && typeof error === "object") return JSON.stringify(error);
   return "unknown";
diff --git a/src/server/generation/llm.ts b/src/server/generation/llm.ts
index b0f3d24..36f20c4 100644
--- a/src/server/generation/llm.ts
+++ b/src/server/generation/llm.ts
@@ -3,6 +3,7 @@ import { buildLayoutSpec, buildLocalizedCopies } from "./copy.js";
 import { extractReadmeContext } from "./readme.js";
 import { selectVisualDirection } from "./visual.js";
 import type {
+  GenerationProvider,
   GitHubRepoMetadata,
   GenerationModelConfig,
   LocalizedCardCopy,
@@ -19,6 +20,15 @@ export const DEFAULT_GENERATION_MODELS: GenerationModelConfig = {
   image: "openai/gpt-image-2/text-to-image",
 };
 
+export const OPENAI_GENERATION_MODELS: GenerationModelConfig = {
+  llm: "gpt-5.5",
+  image: "gpt-image-2",
+};
+
+export const OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
+export const OPENAI_BASE_URL_ENV = "OPENAI_BASE_URL";
+export const OPENAI_API_BASE_URL = "https://api.openai.com/v1";
+export const OPENAI_RESPONSES_URL = `${OPENAI_API_BASE_URL}/responses`;
 export const WAVESPEED_API_KEY_ENV = "WAVESPEED_API_KEY";
 export const WAVESPEED_LLM_BASE_URL = "https://llm.wavespeed.ai/v1";
 export const WAVESPEED_CHAT_COMPLETIONS_URL = `${WAVESPEED_LLM_BASE_URL}/chat/completions`;
@@ -39,7 +49,7 @@ export interface WavespeedChatCompletionRequest {
   };
 }
 
-export function normalizeWavespeedApiKey(value: string) {
+function normalizeBearerToken(value: string) {
   return value
     .trim()
     .replace(/^Bearer\s+/i, "")
@@ -47,6 +57,19 @@ export function normalizeWavespeedApiKey(value: string) {
     .trim();
 }
 
+export const normalizeWavespeedApiKey = normalizeBearerToken;
+export const normalizeOpenAIApiKey = normalizeBearerToken;
+
+export interface OpenAIResponsesRequest {
+  url: string;
+  body: {
+    model: string;
+    instructions: string;
+    input: string;
+    temperature?: number;
+  };
+}
+
 export interface BuildProjectLaunchPlanInput {
   repo: RepoReference;
   metadata: GitHubRepoMetadata;
@@ -74,10 +97,11 @@ export interface ProjectLaunchLlmAdapter {
   buildProjectLaunchPlan(input: BuildProjectLaunchPlanInput): Promise<ProjectLaunchPlan>;
 }
 
-export function resolveGenerationModelConfig(models?: Partial<GenerationModelConfig>): GenerationModelConfig {
+export function resolveGenerationModelConfig(models?: Partial<GenerationModelConfig>, provider: GenerationProvider = "wavespeed"): GenerationModelConfig {
+  const defaults = provider === "openai" ? OPENAI_GENERATION_MODELS : DEFAULT_GENERATION_MODELS;
   return {
-    llm: models?.llm?.trim() || DEFAULT_GENERATION_MODELS.llm,
-    image: models?.image?.trim() || DEFAULT_GENERATION_MODELS.image,
+    llm: models?.llm?.trim() || defaults.llm,
+    image: models?.image?.trim() || defaults.image,
   };
 }
 
@@ -96,6 +120,73 @@ export function buildWavespeedChatCompletionRequest(input: {
   };
 }
 
+export function openAIResponsesUrl() {
+  return `${(process.env[OPENAI_BASE_URL_ENV] ?? OPENAI_API_BASE_URL).replace(/\/+$/, "")}/responses`;
+}
+
+export function buildOpenAIResponsesRequest(input: {
+  model?: string;
+  instructions: string;
+  input: string;
+  temperature?: number;
+}): OpenAIResponsesRequest {
+  return {
+    url: openAIResponsesUrl(),
+    body: {
+      model: input.model?.trim() || OPENAI_GENERATION_MODELS.llm,
+      instructions: input.instructions,
+      input: input.input,
+      ...(input.temperature === undefined ? {} : { temperature: input.temperature }),
+    },
+  };
+}
+
+function extractOpenAIOutputText(body: unknown): string {
+  if (body && typeof body === "object") {
+    const value = body as {
+      output_text?: unknown;
+      output?: Array<{ content?: Array<{ text?: unknown; type?: unknown }> }>;
+    };
+    if (typeof value.output_text === "string" && value.output_text.trim()) {
+      return value.output_text;
+    }
+    const text = value.output
+      ?.flatMap((item) => item.content ?? [])
+      .map((content) => content.text)
+      .find((content): content is string => typeof content === "string" && content.trim().length > 0);
+    if (text) return text;
+  }
+  throw new Error("OpenAI Responses API returned an empty message.");
+}
+
+export async function callOpenAIResponses(input: {
+  apiKey?: string;
+  model?: string;
+  instructions: string;
+  input: string;
+  temperature?: number;
+  fetchImpl?: typeof fetch;
+}): Promise<string> {
+  const apiKey = input.apiKey ?? process.env[OPENAI_API_KEY_ENV];
+  if (!apiKey) {
+    throw new Error(`${OPENAI_API_KEY_ENV} is required to call OpenAI Responses.`);
+  }
+  const normalizedApiKey = normalizeOpenAIApiKey(apiKey);
+  const request = buildOpenAIResponsesRequest(input);
+  const response = await (input.fetchImpl ?? fetch)(request.url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${normalizedApiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(request.body),
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI Responses API failed with ${response.status}.`);
+  }
+  return extractOpenAIOutputText(await response.json());
+}
+
 export async function callWavespeedChatCompletion(input: {
   apiKey?: string;
   model?: string;
@@ -130,6 +221,65 @@ export async function callWavespeedChatCompletion(input: {
   return content;
 }
 
+export function createOpenAILlmAdapter(config: { model?: string; fetchImpl?: typeof fetch } = {}): ProjectLaunchLlmAdapter {
+  const model = config.model?.trim() || OPENAI_GENERATION_MODELS.llm;
+  const readRepositoryContext: ProjectLaunchLlmAdapter["readRepositoryContext"] = async (input) => {
+    await callOpenAIResponses({
+      model,
+      fetchImpl: config.fetchImpl,
+      temperature: 0.2,
+      instructions:
+        "You are QuickFork's repository analyst. Read README and GitHub metadata, then identify positioning, metrics, features, workflow, links, and project identity signals. Return concise source-grounded analysis.",
+      input: JSON.stringify({
+        repo: input.repo,
+        metadata: input.metadata,
+        readmeMarkdown: input.readmeMarkdown.slice(0, 24000),
+      }),
+    });
+    return extractReadmeContext(input.readmeMarkdown, input.repo, input.metadata);
+  };
+
+  return {
+    model,
+    readRepositoryContext,
+    async buildProjectLaunchPlan(input) {
+      const readme =
+        input.readme ??
+        (await readRepositoryContext({
+          repo: input.repo,
+          metadata: input.metadata,
+          readmeMarkdown: input.readmeMarkdown,
+        }));
+      await callOpenAIResponses({
+        model,
+        fetchImpl: config.fetchImpl,
+        temperature: 0.3,
+        instructions:
+          "You are QuickFork's launch-card planner. Produce a concise multilingual launch plan from the repository evidence. Preserve metrics, URLs, identity constraints, and source facts.",
+        input: JSON.stringify({
+          repo: input.repo,
+          metadata: input.metadata,
+          readme: readme.extracted,
+          primaryIdentityAsset: input.primaryIdentityAsset,
+        }),
+      });
+      const brief = buildProjectBrief(input.metadata, readme);
+      const visualDirection = selectVisualDirection(input.metadata, brief);
+      const layout = buildLayoutSpec(input.metadata, brief, input.primaryIdentityAsset);
+      const localizedCopy = buildLocalizedCopies(input.metadata, brief);
+
+      return {
+        model,
+        readme,
+        brief,
+        visualDirection,
+        layout,
+        localizedCopy,
+      };
+    },
+  };
+}
+
 export function createMockLlmAdapter(config: { model?: string } = {}): ProjectLaunchLlmAdapter {
   const model = config.model?.trim() || DEFAULT_GENERATION_MODELS.llm;
   const readRepositoryContext: ProjectLaunchLlmAdapter["readRepositoryContext"] = async (input) =>
diff --git a/src/server/generation/orchestrator.ts b/src/server/generation/orchestrator.ts
index 59ab4e6..b6bec6d 100644
--- a/src/server/generation/orchestrator.ts
+++ b/src/server/generation/orchestrator.ts
@@ -3,14 +3,21 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { resolveBrandAssets, storeReferenceAsset } from "./assets.js";
-import { generateMockImage, generateWavespeedImage } from "./image-generator.js";
+import { generateMockImage, generateOpenAIImage, generateWavespeedImage } from "./image-generator.js";
 import { buildRepoLaunchBrief } from "./launch-brief.js";
-import { WAVESPEED_CHAT_COMPLETIONS_URL, createMockLlmAdapter, createWavespeedLlmAdapter, resolveGenerationModelConfig } from "./llm.js";
-import { WAVESPEED_IMAGE_ENDPOINT, buildImagePrompt } from "./prompt.js";
+import {
+  WAVESPEED_CHAT_COMPLETIONS_URL,
+  createMockLlmAdapter,
+  createOpenAILlmAdapter,
+  createWavespeedLlmAdapter,
+  openAIResponsesUrl,
+  resolveGenerationModelConfig,
+} from "./llm.js";
+import { WAVESPEED_IMAGE_ENDPOINT, buildImagePrompt, openAIImageEndpoint } from "./prompt.js";
 import { inspectMarketingCard } from "./quality.js";
 import { parseGitHubRepositoryUrl } from "./repo.js";
 import { resolveRepositorySource } from "./repository-source.js";
-import type { CreateGenerationInput, GenerationModelCall, GenerationResponse, GenerationStage, LocaleCode } from "./types.js";
+import type { CreateGenerationInput, GenerationModelCall, GenerationProvider, GenerationResponse, GenerationStage, LocaleCode } from "./types.js";
 import { GenerationError } from "./types.js";
 
 const DEFAULT_LOCALES: LocaleCode[] = ["en", "zh", "ja"];
@@ -28,6 +35,55 @@ function responseRepo(owner: string, repo: string) {
   };
 }
 
+function assertSupportedProvider(provider: GenerationProvider) {
+  if (provider !== "mock" && provider !== "openai" && provider !== "wavespeed") {
+    throw new GenerationError("VALIDATION_ERROR", "provider must be openai, wavespeed, or mock.");
+  }
+}
+
+function createLlmAdapter(provider: GenerationProvider, model: string) {
+  if (provider === "openai") return createOpenAILlmAdapter({ model });
+  if (provider === "wavespeed") return createWavespeedLlmAdapter({ model });
+  return createMockLlmAdapter({ model });
+}
+
+function llmEndpoint(provider: GenerationProvider) {
+  if (provider === "openai") return openAIResponsesUrl();
+  if (provider === "wavespeed") return WAVESPEED_CHAT_COMPLETIONS_URL;
+  return undefined;
+}
+
+function llmCallStatus(provider: GenerationProvider) {
+  return provider === "mock" ? "skipped" : "completed";
+}
+
+function readmeStageLabel(provider: GenerationProvider) {
+  if (provider === "openai") return "OpenAI README analysis";
+  if (provider === "wavespeed") return "GPT5.5 README analysis";
+  return "README analysis";
+}
+
+function launchPlanStageLabel(provider: GenerationProvider) {
+  if (provider === "openai") return "OpenAI launch plan";
+  if (provider === "wavespeed") return "GPT5.5 launch plan";
+  return "Launch plan";
+}
+
+function imageEndpoint(provider: GenerationProvider) {
+  if (provider === "openai") return openAIImageEndpoint();
+  if (provider === "wavespeed") return WAVESPEED_IMAGE_ENDPOINT;
+  return undefined;
+}
+
+function imageStageLabel(provider: GenerationProvider, model: string) {
+  if (provider === "mock") return "Mock image render";
+  return `${model} render`;
+}
+
+function imageCallStatus(provider: GenerationProvider, generationStatus: "completed" | "failed") {
+  return provider === "mock" ? "skipped" : generationStatus;
+}
+
 function resolveOutputRoot(outputRoot?: string) {
   if (outputRoot) return outputRoot;
   if (process.env.VERCEL) return join(tmpdir(), "quickfork-output", "project-launch");
@@ -44,15 +100,12 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
   const provider = input.provider ?? "mock";
   const preset = input.preset ?? "4:3";
   const imageQuality = input.imageQuality ?? "low";
-  const modelConfig = resolveGenerationModelConfig(input.models);
-  const llm = provider === "wavespeed" ? createWavespeedLlmAdapter({ model: modelConfig.llm }) : createMockLlmAdapter({ model: modelConfig.llm });
+  assertSupportedProvider(provider);
+  const modelConfig = resolveGenerationModelConfig(input.models, provider);
+  const llm = createLlmAdapter(provider, modelConfig.llm);
   const stages: GenerationStage[] = [];
   const modelCalls: GenerationModelCall[] = [];
 
-  if (provider !== "mock" && provider !== "wavespeed") {
-    throw new GenerationError("VALIDATION_ERROR", "provider must be wavespeed.");
-  }
-
   const repositorySource = await resolveRepositorySource(repo, input);
   stages.push({
     id: "repo",
@@ -64,16 +117,16 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
   const readme = await llm.readRepositoryContext({ repo, metadata, readmeMarkdown });
   stages.push({
     id: "readme",
-    label: provider === "wavespeed" ? "GPT5.5 README analysis" : "README analysis",
+    label: readmeStageLabel(provider),
     status: "completed",
     model: modelConfig.llm,
   });
   modelCalls.push({
     provider,
     model: modelConfig.llm,
-    endpoint: provider === "wavespeed" ? WAVESPEED_CHAT_COMPLETIONS_URL : undefined,
+    endpoint: llmEndpoint(provider),
     purpose: "readme_analysis",
-    status: provider === "wavespeed" ? "completed" : "skipped",
+    status: llmCallStatus(provider),
   });
   const { primaryAsset } = resolveBrandAssets(repo, metadata, readme);
 
@@ -91,16 +144,16 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
   });
   stages.push({
     id: "brief",
-    label: provider === "wavespeed" ? "GPT5.5 launch plan" : "Launch plan",
+    label: launchPlanStageLabel(provider),
     status: "completed",
     model: modelConfig.llm,
   });
   modelCalls.push({
     provider,
     model: modelConfig.llm,
-    endpoint: provider === "wavespeed" ? WAVESPEED_CHAT_COMPLETIONS_URL : undefined,
+    endpoint: llmEndpoint(provider),
     purpose: "launch_plan",
-    status: provider === "wavespeed" ? "completed" : "skipped",
+    status: llmCallStatus(provider),
   });
   const { brief, visualDirection, layout, localizedCopy } = plan;
   const launchBrief = buildRepoLaunchBrief({
@@ -140,9 +193,11 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
       });
     }
     const generated =
-      provider === "wavespeed"
-        ? await generateWavespeedImage(localeDir, locale, prompt, { preset })
-        : await generateMockImage(localeDir, locale, prompt);
+      provider === "openai"
+        ? await generateOpenAIImage(localeDir, locale, prompt, { preset })
+        : provider === "wavespeed"
+          ? await generateWavespeedImage(localeDir, locale, prompt, { preset })
+          : await generateMockImage(localeDir, locale, prompt);
     if (generated.status === "failed") {
       hasImageFailure = true;
     }
@@ -168,16 +223,16 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
   const generationStatus = hasImageFailure ? "failed" : "completed";
   stages.push({
     id: "image",
-    label: provider === "wavespeed" ? "gpt-image-2 render" : "Mock image render",
+    label: imageStageLabel(provider, modelConfig.image),
     status: generationStatus,
     model: modelConfig.image,
   });
   modelCalls.push({
     provider,
     model: modelConfig.image,
-    endpoint: provider === "wavespeed" ? WAVESPEED_IMAGE_ENDPOINT : undefined,
+    endpoint: imageEndpoint(provider),
     purpose: "image_generation",
-    status: provider === "wavespeed" ? generationStatus : "skipped",
+    status: imageCallStatus(provider, generationStatus),
   });
   stages.push({
     id: "quality",
diff --git a/src/server/generation/prompt.ts b/src/server/generation/prompt.ts
index 206f320..375f3e0 100644
--- a/src/server/generation/prompt.ts
+++ b/src/server/generation/prompt.ts
@@ -1,5 +1,5 @@
 import type { ImagePromptResult, ImageQuality, LocalizedCardCopy, MarketingCardLayoutSpec, ProjectBrief, StoredReferenceAsset, VisualDirection } from "./types.js";
-import { DEFAULT_GENERATION_MODELS } from "./llm.js";
+import { DEFAULT_GENERATION_MODELS, OPENAI_API_BASE_URL, OPENAI_BASE_URL_ENV, OPENAI_GENERATION_MODELS } from "./llm.js";
 
 const PRESET_SIZES = {
   "1:1": "1200x1200",
@@ -29,6 +29,11 @@ const PRESET_ASPECT_RATIOS = {
 
 export const WAVESPEED_IMAGE_ENDPOINT = "https://api.wavespeed.ai/api/v3/openai/gpt-image-2/text-to-image";
 export const WAVESPEED_PREDICTIONS_ENDPOINT = "https://api.wavespeed.ai/api/v3/predictions";
+export const OPENAI_IMAGE_ENDPOINT = "https://api.openai.com/v1/images/generations";
+
+export function openAIImageEndpoint() {
+  return `${(process.env[OPENAI_BASE_URL_ENV] ?? OPENAI_API_BASE_URL).replace(/\/+$/, "")}/images/generations`;
+}
 
 export function imageSizeForPreset(preset: keyof typeof PRESET_SIZES) {
   return PRESET_SIZES[preset];
@@ -42,6 +47,37 @@ export function normalizeWavespeedImageQuality(_quality: ImageQuality) {
   return "low";
 }
 
+export function openAIImageSizeForPreset(preset: keyof typeof PRESET_ASPECT_RATIOS) {
+  if (preset === "1:1") return "1024x1024";
+  if (["2:3", "3:4", "4:5", "9:16"].includes(preset)) return "1024x1536";
+  return "1536x1024";
+}
+
+export function normalizeOpenAIImageQuality(_quality: ImageQuality) {
+  return "low";
+}
+
+export function buildOpenAIImageRequest(input: {
+  model?: string;
+  prompt: string;
+  preset: keyof typeof PRESET_ASPECT_RATIOS;
+  quality: ImageQuality;
+}) {
+  const model = input.model?.trim() || OPENAI_GENERATION_MODELS.image;
+  return {
+    url: openAIImageEndpoint(),
+    model,
+    body: {
+      model,
+      prompt: input.prompt,
+      size: openAIImageSizeForPreset(input.preset),
+      quality: normalizeOpenAIImageQuality(input.quality),
+      n: 1,
+      output_format: "png",
+    },
+  };
+}
+
 export function buildWavespeedImageRequest(input: {
   model?: string;
   prompt: string;
diff --git a/src/server/generation/types.ts b/src/server/generation/types.ts
index 834c7de..0aa0e23 100644
--- a/src/server/generation/types.ts
+++ b/src/server/generation/types.ts
@@ -1,5 +1,5 @@
 export type LocaleCode = "en" | "zh" | "ja";
-export type GenerationProvider = "mock" | "wavespeed";
+export type GenerationProvider = "mock" | "openai" | "wavespeed";
 export type OutputPreset =
   | "1:1"
   | "3:2"

From fb08ae9ea5b417ac4fff1a1dcdaa51cf7211bfa1 Mon Sep 17 00:00:00 2001
From: moose-lab <mooseindiehacker@gmail.com>
Date: Mon, 8 Jun 2026 17:18:26 +0800
Subject: [PATCH 2/2] feat: default to ChatGPT OAuth generation

---
 .env.example                             |  2 +
 README.md                                |  8 ++-
 api/generations.test.ts                  | 36 +++++++++--
 api/generations.ts                       | 33 ++++++++--
 src/App.test.tsx                         | 10 +--
 src/components/landing/HeroSection.tsx   |  4 +-
 src/server/generation/generation.test.ts | 79 ++++++++++++++++++++++++
 src/server/generation/image-generator.ts | 12 ++--
 src/server/generation/llm.ts             | 35 ++++++++++-
 src/server/generation/orchestrator.ts    | 38 +++++++++---
 src/server/generation/types.ts           |  8 ++-
 11 files changed, 228 insertions(+), 37 deletions(-)

diff --git a/.env.example b/.env.example
index 9203a2d..05c1154 100644
--- a/.env.example
+++ b/.env.example
@@ -1,5 +1,7 @@
 # Server-side only. Never expose real API keys in browser code.
 OPENAI_API_KEY=
+# Optional local/dev token for provider="chatgpt-oauth" when no ChatGPT Action Authorization header is present.
+CHATGPT_OAUTH_ACCESS_TOKEN=
 # Optional override for OpenAI-compatible API gateways. Leave blank for https://api.openai.com/v1.
 OPENAI_BASE_URL=
 # Optional fallback provider for /api/generations when provider is set to "wavespeed".
diff --git a/README.md b/README.md
index a655778..8867084 100644
--- a/README.md
+++ b/README.md
@@ -116,6 +116,8 @@ Secrets belong on the server, not in browser code:
 
 ```env
 OPENAI_API_KEY=
+# Optional local/dev token for provider="chatgpt-oauth" when no ChatGPT Action Authorization header is present.
+CHATGPT_OAUTH_ACCESS_TOKEN=
 # Optional OpenAI-compatible gateway override. Leave blank for the official OpenAI API.
 OPENAI_BASE_URL=
 # Optional fallback provider key when /api/generations uses provider="wavespeed".
@@ -158,13 +160,13 @@ https://your-domain.example/api/auth/callback/google
 `POST /api/generations` runs the server-side launch-card workflow:
 
 1. fetches GitHub repository metadata and README content, with deterministic fallback data for failed source lookups
-2. calls OpenAI Responses for repository analysis and launch planning when `provider` is `openai`
+2. calls OpenAI Responses for repository analysis and launch planning when `provider` is `chatgpt-oauth` or `openai`
 3. calls OpenAI Images for the marketing card render and returns `outputs[locale].imageUrl` for browser preview
 4. writes prompt, image, quality report, and manifest artifacts under the server output root
 
-The Hero generator sends `provider: "openai"` by default and requires `OPENAI_API_KEY` in server runtime configuration. The API still accepts `provider: "mock"` for tests and `provider: "wavespeed"` for the existing Wavespeed-compatible path.
+The Hero generator sends `provider: "chatgpt-oauth"` by default, and the backend uses `chatgpt-oauth` when `provider` is omitted. For ChatGPT Action traffic, QuickFork reads the OAuth bearer token from the request `Authorization` header and uses it for repo analysis, launch planning, and image generation. For local development or server-side fallback, set `CHATGPT_OAUTH_ACCESS_TOKEN`.
 
-ChatGPT OAuth is not used for this backend path. ChatGPT Actions OAuth authenticates ChatGPT to a third-party action API; QuickFork's own web backend calls OpenAI directly with a server-side API key.
+The API still accepts `provider: "openai"` with `OPENAI_API_KEY`, `provider: "mock"` for tests, and `provider: "wavespeed"` for the existing Wavespeed-compatible path. OAuth tokens are never written into manifests or API responses; model call metadata records only the credential source.
 
 ## Local Development
 
diff --git a/api/generations.test.ts b/api/generations.test.ts
index d41db17..7151f3e 100644
--- a/api/generations.test.ts
+++ b/api/generations.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 
-import { normalizeCreateGenerationInput } from "./generations.js";
+import { attachRequestAuth, normalizeCreateGenerationInput } from "./generations.js";
 
 describe("/api/generations input contract", () => {
   it("normalizes a valid project launch generation request", () => {
@@ -9,7 +9,7 @@ describe("/api/generations input contract", () => {
         repoUrl: " https://github.com/QwenLM/FlashQLA ",
         locales: ["en", "zh"],
         preset: "4:3",
-        provider: "openai",
+        provider: "chatgpt-oauth",
         imageQuality: "low",
         models: {
           llm: "gpt-5.5",
@@ -20,7 +20,7 @@ describe("/api/generations input contract", () => {
       repoUrl: "https://github.com/QwenLM/FlashQLA",
       locales: ["en", "zh"],
       preset: "4:3",
-      provider: "openai",
+      provider: "chatgpt-oauth",
       imageQuality: "low",
       models: {
         llm: "gpt-5.5",
@@ -60,7 +60,13 @@ describe("/api/generations input contract", () => {
     ).toThrow(/locales/i);
   });
 
-  it("accepts direct OpenAI and Wavespeed providers while rejecting unknown providers", () => {
+  it("accepts ChatGPT OAuth, direct OpenAI, and Wavespeed providers while rejecting unknown providers", () => {
+    expect(
+      normalizeCreateGenerationInput({
+        repoUrl: "https://github.com/QwenLM/FlashQLA",
+        provider: "chatgpt-oauth",
+      }).provider,
+    ).toBe("chatgpt-oauth");
     expect(
       normalizeCreateGenerationInput({
         repoUrl: "https://github.com/QwenLM/FlashQLA",
@@ -76,8 +82,26 @@ describe("/api/generations input contract", () => {
     expect(() =>
       normalizeCreateGenerationInput({
         repoUrl: "https://github.com/QwenLM/FlashQLA",
-        provider: "chatgpt-oauth",
+        provider: "manual-oauth",
       }),
-    ).toThrow("provider must be openai, wavespeed, or mock.");
+    ).toThrow("provider must be chatgpt-oauth, openai, wavespeed, or mock.");
+  });
+
+  it("attaches ChatGPT Action OAuth bearer tokens from the request header only", () => {
+    const normalized = normalizeCreateGenerationInput({
+      repoUrl: "https://github.com/QwenLM/FlashQLA",
+      provider: "chatgpt-oauth",
+      auth: {
+        bearerToken: "body-token-must-not-be-trusted",
+      },
+    } as unknown);
+    const withAuth = attachRequestAuth(normalized, "Bearer “oauth-user-token”");
+
+    expect(normalized.auth).toBeUndefined();
+    expect(withAuth.auth).toEqual({
+      bearerToken: "oauth-user-token",
+      source: "request_header",
+    });
+    expect(JSON.stringify(withAuth)).not.toContain("Bearer");
   });
 });
diff --git a/api/generations.ts b/api/generations.ts
index ac4a5b1..bc38c65 100644
--- a/api/generations.ts
+++ b/api/generations.ts
@@ -3,6 +3,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { runProjectLaunchGeneration } from "../src/server/generation/orchestrator.js";
 import type { CreateGenerationInput } from "../src/server/generation/types.js";
 import { GenerationError } from "../src/server/generation/types.js";
+import { normalizeOpenAIApiKey } from "../src/server/generation/llm.js";
 
 type ApiErrorCode = "VALIDATION_ERROR" | "METHOD_NOT_ALLOWED" | "GENERATION_FAILED";
 const localeValues = ["en", "zh", "ja"] as const;
@@ -18,7 +19,7 @@ const presetValues = [
   "16:9",
   "21:9",
 ] as const;
-const providerValues = ["mock", "openai", "wavespeed"] as const;
+const providerValues = ["mock", "chatgpt-oauth", "openai", "wavespeed"] as const;
 const qualityValues = ["low"] as const;
 
 function sendJson(res: ServerResponse, statusCode: number, body: unknown) {
@@ -67,7 +68,7 @@ export function normalizeCreateGenerationInput(body: unknown): CreateGenerationI
   if (!body || typeof body !== "object") {
     throw new GenerationError("VALIDATION_ERROR", "Request body must be a JSON object.");
   }
-  const value = body as Partial<CreateGenerationInput>;
+  const { auth: _untrustedAuth, ...value } = body as Partial<CreateGenerationInput> & { auth?: unknown };
   if (typeof value.repoUrl !== "string" || !value.repoUrl.trim()) {
     throw new GenerationError("VALIDATION_ERROR", "repoUrl is required.");
   }
@@ -80,7 +81,7 @@ export function normalizeCreateGenerationInput(body: unknown): CreateGenerationI
     throw new GenerationError("VALIDATION_ERROR", "preset is not supported.");
   }
   if (value.provider !== undefined && !isOneOf(value.provider, providerValues)) {
-    throw new GenerationError("VALIDATION_ERROR", "provider must be openai, wavespeed, or mock.");
+    throw new GenerationError("VALIDATION_ERROR", "provider must be chatgpt-oauth, openai, wavespeed, or mock.");
   }
   if (value.imageQuality !== undefined && !isOneOf(value.imageQuality, qualityValues)) {
     throw new GenerationError("VALIDATION_ERROR", "imageQuality must be low.");
@@ -98,6 +99,30 @@ export function normalizeCreateGenerationInput(body: unknown): CreateGenerationI
   } as CreateGenerationInput;
 }
 
+function authorizationHeaderValue(value: string | string[] | undefined) {
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function bearerTokenFromAuthorizationHeader(value: string | string[] | undefined) {
+  const header = authorizationHeaderValue(value);
+  if (!header?.trim()) return undefined;
+  const match = header.match(/^Bearer\s+(.+)$/i);
+  if (!match?.[1]) return undefined;
+  return normalizeOpenAIApiKey(match[1]);
+}
+
+export function attachRequestAuth(input: CreateGenerationInput, authorizationHeader: string | string[] | undefined): CreateGenerationInput {
+  const bearerToken = bearerTokenFromAuthorizationHeader(authorizationHeader);
+  if (!bearerToken) return input;
+  return {
+    ...input,
+    auth: {
+      bearerToken,
+      source: "request_header",
+    },
+  };
+}
+
 export default async function handler(req: IncomingMessage, res: ServerResponse) {
   if (req.method !== "POST") {
     res.setHeader("Allow", "POST");
@@ -107,7 +132,7 @@ export default async function handler(req: IncomingMessage, res: ServerResponse)
 
   try {
     const body = await readJsonBody(req);
-    const input = normalizeCreateGenerationInput(body);
+    const input = attachRequestAuth(normalizeCreateGenerationInput(body), req.headers.authorization);
     const result = await runProjectLaunchGeneration(input);
     sendJson(res, 201, result);
   } catch (error) {
diff --git a/src/App.test.tsx b/src/App.test.tsx
index 5ac3847..74958e8 100644
--- a/src/App.test.tsx
+++ b/src/App.test.tsx
@@ -1363,12 +1363,12 @@ describe("App", () => {
           },
           stages: [
             { id: "repo", label: "Repository source", status: "completed" },
-            { id: "readme", label: "OpenAI README analysis", status: "completed", model: "gpt-5.5" },
+            { id: "readme", label: "ChatGPT OAuth README analysis", status: "completed", model: "gpt-5.5" },
             { id: "image", label: "gpt-image-2 render", status: "completed", model: "gpt-image-2" },
           ],
           modelCalls: [
-            { provider: "openai", model: "gpt-5.5", purpose: "readme_analysis", status: "completed" },
-            { provider: "openai", model: "gpt-image-2", purpose: "image_generation", status: "completed" },
+            { provider: "chatgpt-oauth", model: "gpt-5.5", purpose: "readme_analysis", status: "completed" },
+            { provider: "chatgpt-oauth", model: "gpt-image-2", purpose: "image_generation", status: "completed" },
           ],
           launchBrief: {
             summary: "CUDA kernels for faster attention inference.",
@@ -1562,14 +1562,14 @@ describe("App", () => {
       repoUrl: "https://github.com/QwenLM/FlashQLA",
       locales: ["en"],
       preset: "4:3",
-      provider: "openai",
+      provider: "chatgpt-oauth",
       imageQuality: "low",
     });
     expect(await screen.findByText(/generated gen_qwenlm_flashqla_test/i)).toBeInTheDocument();
     const previewImage = await within(form).findByRole("img", { name: /qwenlm\/flashqla launch card/i });
     const controls = form.querySelector(".referenceControls");
     expect(previewImage).toHaveAttribute("src", "data:image/png;base64,cXdlbmxtLWZsYXNocWxh");
-    expect(previewImage.closest(".generationPreview")).toHaveAccessibleName("Generated OpenAI image result");
+    expect(previewImage.closest(".generationPreview")).toHaveAccessibleName("Generated ChatGPT OAuth image result");
     expect(controls).not.toBeNull();
     expect((controls?.compareDocumentPosition(previewImage) ?? 0) & Node.DOCUMENT_POSITION_FOLLOWING).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
     expect(within(form).getByRole("link", { name: /download generated image/i })).toHaveAttribute(
diff --git a/src/components/landing/HeroSection.tsx b/src/components/landing/HeroSection.tsx
index da54c95..158e226 100644
--- a/src/components/landing/HeroSection.tsx
+++ b/src/components/landing/HeroSection.tsx
@@ -208,7 +208,7 @@ async function createGeneration(input: {
       repoUrl: input.repoUrl,
       locales: input.locales,
       preset: input.preset,
-      provider: "openai",
+      provider: "chatgpt-oauth",
       imageQuality: input.imageQuality,
     }),
   });
@@ -399,7 +399,7 @@ function ProjectLaunchInputPanel() {
           </label>
         </div>
         {generatedImageUrl ? (
-          <figure className="generationPreview" aria-label="Generated OpenAI image result">
+          <figure className="generationPreview" aria-label="Generated ChatGPT OAuth image result">
             <button
               aria-label="Open generated image preview"
               className="generationPreviewButton"
diff --git a/src/server/generation/generation.test.ts b/src/server/generation/generation.test.ts
index d185b12..df2962f 100644
--- a/src/server/generation/generation.test.ts
+++ b/src/server/generation/generation.test.ts
@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import {
+  CHATGPT_OAUTH_ACCESS_TOKEN_ENV,
   createMockLlmAdapter,
   DEFAULT_GENERATION_MODELS,
   OPENAI_API_KEY_ENV,
@@ -76,6 +77,7 @@ const openDesignMetadata = {
 describe("project launch generation backend", () => {
   afterEach(() => {
     vi.unstubAllGlobals();
+    delete process.env.CHATGPT_OAUTH_ACCESS_TOKEN;
     delete process.env.OPENAI_API_KEY;
     delete process.env.OPENAI_BASE_URL;
     delete process.env.WAVESPEED_API_KEY;
@@ -1105,6 +1107,83 @@ describe("project launch generation backend", () => {
     }
   });
 
+  it("defaults to ChatGPT OAuth bearer auth for repo analysis, launch planning, and image generation", async () => {
+    const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-chatgpt-oauth-generation-"));
+    const fetchMock = vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
+      const endpoint = String(url);
+      const headers = init?.headers as Record<string, string>;
+      expect(headers.Authorization).toBe("Bearer oauth-user-token");
+      if (endpoint === OPENAI_RESPONSES_URL) {
+        return new Response(JSON.stringify({ output_text: "Use deterministic project evidence from the README." }), {
+          headers: { "Content-Type": "application/json" },
+          status: 200,
+        });
+      }
+      if (endpoint === OPENAI_IMAGE_ENDPOINT) {
+        return new Response(JSON.stringify({ data: [{ b64_json: Buffer.from("oauth-card").toString("base64") }] }), {
+          headers: { "Content-Type": "application/json" },
+          status: 200,
+        });
+      }
+      throw new Error(`Unexpected fetch: ${endpoint}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const result = await runProjectLaunchGeneration({
+        repoUrl: "https://github.com/QwenLM/FlashQLA",
+        locales: ["en"],
+        preset: "16:9",
+        imageQuality: "low",
+        outputRoot,
+        auth: {
+          bearerToken: "Bearer “oauth-user-token”",
+          source: "request_header",
+        },
+        mock: {
+          readmeMarkdown: openDesignReadme,
+        },
+      });
+      const manifest = JSON.parse(await readFile(result.manifestPath, "utf8")) as {
+        modelCalls: Array<{ provider: string; purpose: string; credentialSource?: string }>;
+      };
+
+      expect(fetchMock).toHaveBeenCalledTimes(3);
+      expect(result.modelCalls).toMatchObject([
+        { provider: "chatgpt-oauth", model: "gpt-5.5", endpoint: "https://api.openai.com/v1/responses", purpose: "readme_analysis", status: "completed", credentialSource: "request_header" },
+        { provider: "chatgpt-oauth", model: "gpt-5.5", endpoint: "https://api.openai.com/v1/responses", purpose: "launch_plan", status: "completed", credentialSource: "request_header" },
+        { provider: "chatgpt-oauth", model: "gpt-image-2", endpoint: "https://api.openai.com/v1/images/generations", purpose: "image_generation", status: "completed", credentialSource: "request_header" },
+      ]);
+      expect(result.outputs.en.imageUrl).toBe(`data:image/png;base64,${Buffer.from("oauth-card").toString("base64")}`);
+      expect(JSON.stringify(manifest)).not.toContain("oauth-user-token");
+    } finally {
+      await rm(outputRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("requires a ChatGPT OAuth bearer token when provider is chatgpt-oauth", async () => {
+    const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-chatgpt-oauth-missing-token-"));
+    const fetchMock = vi.fn();
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      await expect(
+        runProjectLaunchGeneration({
+          repoUrl: "https://github.com/QwenLM/FlashQLA",
+          locales: ["en"],
+          provider: "chatgpt-oauth",
+          outputRoot,
+          mock: {
+            readmeMarkdown: openDesignReadme,
+          },
+        }),
+      ).rejects.toThrow(`${CHATGPT_OAUTH_ACCESS_TOKEN_ENV} or request Authorization bearer token is required`);
+      expect(fetchMock).not.toHaveBeenCalled();
+    } finally {
+      await rm(outputRoot, { recursive: true, force: true });
+    }
+  });
+
   it("calls Wavespeed GPT5.5 and gpt-image-2 when provider is wavespeed", async () => {
     const outputRoot = await mkdtemp(join(tmpdir(), "quickfork-wavespeed-generation-"));
     process.env.WAVESPEED_API_KEY = "test-wavespeed-key";
diff --git a/src/server/generation/image-generator.ts b/src/server/generation/image-generator.ts
index 35e998c..a2c3e61 100644
--- a/src/server/generation/image-generator.ts
+++ b/src/server/generation/image-generator.ts
@@ -1,7 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
-import type { GeneratedImageResult, ImagePromptResult, LocaleCode } from "./types.js";
+import type { GeneratedImageResult, GenerationProvider, ImagePromptResult, LocaleCode } from "./types.js";
 import { OPENAI_API_KEY_ENV, WAVESPEED_API_KEY_ENV, normalizeOpenAIApiKey, normalizeWavespeedApiKey } from "./llm.js";
 import { WAVESPEED_PREDICTIONS_ENDPOINT, buildOpenAIImageRequest, buildWavespeedImageRequest } from "./prompt.js";
 
@@ -52,6 +52,7 @@ export async function generateOpenAIImage(
   input: {
     preset: Parameters<typeof buildOpenAIImageRequest>[0]["preset"];
     apiKey?: string;
+    provider?: Extract<GenerationProvider, "chatgpt-oauth" | "openai">;
     fetchImpl?: typeof fetch;
   },
 ): Promise<GeneratedImageResult> {
@@ -86,6 +87,7 @@ export async function generateOpenAIImage(
       prompt,
       promptPath,
       model: request.model,
+      provider: input.provider ?? "openai",
       message: `OpenAI image generation failed with ${response.status}.`,
     });
   }
@@ -95,7 +97,7 @@ export async function generateOpenAIImage(
   if (typeof firstImage?.b64_json === "string" && firstImage.b64_json.trim()) {
     await writeFile(imagePath, Buffer.from(firstImage.b64_json, "base64"));
     return {
-      provider: "openai",
+      provider: input.provider ?? "openai",
       model: request.model,
       status: "completed",
       imagePath,
@@ -108,7 +110,7 @@ export async function generateOpenAIImage(
   if (typeof firstImage?.url === "string" && firstImage.url.trim()) {
     await writeFile(imagePath, `OpenAI image URL\n${firstImage.url}\n`, "utf8");
     return {
-      provider: "openai",
+      provider: input.provider ?? "openai",
       model: request.model,
       status: "completed",
       imagePath,
@@ -124,6 +126,7 @@ export async function generateOpenAIImage(
     prompt,
     promptPath,
     model: request.model,
+    provider: input.provider ?? "openai",
     message: `OpenAI image generation returned no image for ${locale}. error=${formatProviderError(body.error)}`,
   });
 }
@@ -250,11 +253,12 @@ async function writeFailedOpenAIImage(input: {
   prompt: ImagePromptResult;
   promptPath: string;
   model: string;
+  provider?: Extract<GenerationProvider, "chatgpt-oauth" | "openai">;
   message: string;
 }): Promise<GeneratedImageResult> {
   await writeFile(input.imagePath, `OpenAI image generation failed\n${input.message}\n`, "utf8");
   return {
-    provider: "openai",
+    provider: input.provider ?? "openai",
     model: input.model,
     status: "failed",
     imagePath: input.imagePath,
diff --git a/src/server/generation/llm.ts b/src/server/generation/llm.ts
index 36f20c4..c65d57a 100644
--- a/src/server/generation/llm.ts
+++ b/src/server/generation/llm.ts
@@ -2,8 +2,10 @@ import { buildProjectBrief } from "./brief.js";
 import { buildLayoutSpec, buildLocalizedCopies } from "./copy.js";
 import { extractReadmeContext } from "./readme.js";
 import { selectVisualDirection } from "./visual.js";
+import { GenerationError } from "./types.js";
 import type {
   GenerationProvider,
+  GenerationCredentialSource,
   GitHubRepoMetadata,
   GenerationModelConfig,
   LocalizedCardCopy,
@@ -11,6 +13,7 @@ import type {
   ProjectBrief,
   ReadmeContext,
   RepoReference,
+  CreateGenerationInput,
   StoredReferenceAsset,
   VisualDirection,
 } from "./types.js";
@@ -29,6 +32,7 @@ export const OPENAI_API_KEY_ENV = "OPENAI_API_KEY";
 export const OPENAI_BASE_URL_ENV = "OPENAI_BASE_URL";
 export const OPENAI_API_BASE_URL = "https://api.openai.com/v1";
 export const OPENAI_RESPONSES_URL = `${OPENAI_API_BASE_URL}/responses`;
+export const CHATGPT_OAUTH_ACCESS_TOKEN_ENV = "CHATGPT_OAUTH_ACCESS_TOKEN";
 export const WAVESPEED_API_KEY_ENV = "WAVESPEED_API_KEY";
 export const WAVESPEED_LLM_BASE_URL = "https://llm.wavespeed.ai/v1";
 export const WAVESPEED_CHAT_COMPLETIONS_URL = `${WAVESPEED_LLM_BASE_URL}/chat/completions`;
@@ -60,6 +64,11 @@ function normalizeBearerToken(value: string) {
 export const normalizeWavespeedApiKey = normalizeBearerToken;
 export const normalizeOpenAIApiKey = normalizeBearerToken;
 
+export interface GenerationBearerCredential {
+  bearerToken: string;
+  source: GenerationCredentialSource;
+}
+
 export interface OpenAIResponsesRequest {
   url: string;
   body: {
@@ -98,13 +107,33 @@ export interface ProjectLaunchLlmAdapter {
 }
 
 export function resolveGenerationModelConfig(models?: Partial<GenerationModelConfig>, provider: GenerationProvider = "wavespeed"): GenerationModelConfig {
-  const defaults = provider === "openai" ? OPENAI_GENERATION_MODELS : DEFAULT_GENERATION_MODELS;
+  const defaults = provider === "openai" || provider === "chatgpt-oauth" ? OPENAI_GENERATION_MODELS : DEFAULT_GENERATION_MODELS;
   return {
     llm: models?.llm?.trim() || defaults.llm,
     image: models?.image?.trim() || defaults.image,
   };
 }
 
+export function resolveChatGptOAuthCredential(auth?: CreateGenerationInput["auth"]): GenerationBearerCredential {
+  if (auth?.bearerToken) {
+    return {
+      bearerToken: normalizeOpenAIApiKey(auth.bearerToken),
+      source: auth.source,
+    };
+  }
+  const environmentToken = process.env[CHATGPT_OAUTH_ACCESS_TOKEN_ENV];
+  if (environmentToken) {
+    return {
+      bearerToken: normalizeOpenAIApiKey(environmentToken),
+      source: "environment",
+    };
+  }
+  throw new GenerationError(
+    "VALIDATION_ERROR",
+    `${CHATGPT_OAUTH_ACCESS_TOKEN_ENV} or request Authorization bearer token is required to use provider chatgpt-oauth.`,
+  );
+}
+
 export function buildWavespeedChatCompletionRequest(input: {
   model?: string;
   messages: WavespeedChatMessage[];
@@ -221,10 +250,11 @@ export async function callWavespeedChatCompletion(input: {
   return content;
 }
 
-export function createOpenAILlmAdapter(config: { model?: string; fetchImpl?: typeof fetch } = {}): ProjectLaunchLlmAdapter {
+export function createOpenAILlmAdapter(config: { model?: string; apiKey?: string; fetchImpl?: typeof fetch } = {}): ProjectLaunchLlmAdapter {
   const model = config.model?.trim() || OPENAI_GENERATION_MODELS.llm;
   const readRepositoryContext: ProjectLaunchLlmAdapter["readRepositoryContext"] = async (input) => {
     await callOpenAIResponses({
+      apiKey: config.apiKey,
       model,
       fetchImpl: config.fetchImpl,
       temperature: 0.2,
@@ -251,6 +281,7 @@ export function createOpenAILlmAdapter(config: { model?: string; fetchImpl?: typ
           readmeMarkdown: input.readmeMarkdown,
         }));
       await callOpenAIResponses({
+        apiKey: config.apiKey,
         model,
         fetchImpl: config.fetchImpl,
         temperature: 0.3,
diff --git a/src/server/generation/orchestrator.ts b/src/server/generation/orchestrator.ts
index b6bec6d..ae777f8 100644
--- a/src/server/generation/orchestrator.ts
+++ b/src/server/generation/orchestrator.ts
@@ -11,13 +11,14 @@ import {
   createOpenAILlmAdapter,
   createWavespeedLlmAdapter,
   openAIResponsesUrl,
+  resolveChatGptOAuthCredential,
   resolveGenerationModelConfig,
 } from "./llm.js";
 import { WAVESPEED_IMAGE_ENDPOINT, buildImagePrompt, openAIImageEndpoint } from "./prompt.js";
 import { inspectMarketingCard } from "./quality.js";
 import { parseGitHubRepositoryUrl } from "./repo.js";
 import { resolveRepositorySource } from "./repository-source.js";
-import type { CreateGenerationInput, GenerationModelCall, GenerationProvider, GenerationResponse, GenerationStage, LocaleCode } from "./types.js";
+import type { CreateGenerationInput, GenerationCredentialSource, GenerationModelCall, GenerationProvider, GenerationResponse, GenerationStage, LocaleCode } from "./types.js";
 import { GenerationError } from "./types.js";
 
 const DEFAULT_LOCALES: LocaleCode[] = ["en", "zh", "ja"];
@@ -36,19 +37,20 @@ function responseRepo(owner: string, repo: string) {
 }
 
 function assertSupportedProvider(provider: GenerationProvider) {
-  if (provider !== "mock" && provider !== "openai" && provider !== "wavespeed") {
-    throw new GenerationError("VALIDATION_ERROR", "provider must be openai, wavespeed, or mock.");
+  if (provider !== "mock" && provider !== "chatgpt-oauth" && provider !== "openai" && provider !== "wavespeed") {
+    throw new GenerationError("VALIDATION_ERROR", "provider must be chatgpt-oauth, openai, wavespeed, or mock.");
   }
 }
 
-function createLlmAdapter(provider: GenerationProvider, model: string) {
+function createLlmAdapter(provider: GenerationProvider, model: string, bearerToken?: string) {
+  if (provider === "chatgpt-oauth") return createOpenAILlmAdapter({ model, apiKey: bearerToken });
   if (provider === "openai") return createOpenAILlmAdapter({ model });
   if (provider === "wavespeed") return createWavespeedLlmAdapter({ model });
   return createMockLlmAdapter({ model });
 }
 
 function llmEndpoint(provider: GenerationProvider) {
-  if (provider === "openai") return openAIResponsesUrl();
+  if (provider === "chatgpt-oauth" || provider === "openai") return openAIResponsesUrl();
   if (provider === "wavespeed") return WAVESPEED_CHAT_COMPLETIONS_URL;
   return undefined;
 }
@@ -58,19 +60,21 @@ function llmCallStatus(provider: GenerationProvider) {
 }
 
 function readmeStageLabel(provider: GenerationProvider) {
+  if (provider === "chatgpt-oauth") return "ChatGPT OAuth README analysis";
   if (provider === "openai") return "OpenAI README analysis";
   if (provider === "wavespeed") return "GPT5.5 README analysis";
   return "README analysis";
 }
 
 function launchPlanStageLabel(provider: GenerationProvider) {
+  if (provider === "chatgpt-oauth") return "ChatGPT OAuth launch plan";
   if (provider === "openai") return "OpenAI launch plan";
   if (provider === "wavespeed") return "GPT5.5 launch plan";
   return "Launch plan";
 }
 
 function imageEndpoint(provider: GenerationProvider) {
-  if (provider === "openai") return openAIImageEndpoint();
+  if (provider === "chatgpt-oauth" || provider === "openai") return openAIImageEndpoint();
   if (provider === "wavespeed") return WAVESPEED_IMAGE_ENDPOINT;
   return undefined;
 }
@@ -84,6 +88,10 @@ function imageCallStatus(provider: GenerationProvider, generationStatus: "comple
   return provider === "mock" ? "skipped" : generationStatus;
 }
 
+function credentialSource(provider: GenerationProvider, source?: GenerationCredentialSource) {
+  return provider === "chatgpt-oauth" ? source : undefined;
+}
+
 function resolveOutputRoot(outputRoot?: string) {
   if (outputRoot) return outputRoot;
   if (process.env.VERCEL) return join(tmpdir(), "quickfork-output", "project-launch");
@@ -97,12 +105,13 @@ async function writeJson(path: string, value: unknown) {
 export async function runProjectLaunchGeneration(input: CreateGenerationInput): Promise<GenerationResponse> {
   const repo = parseGitHubRepositoryUrl(input.repoUrl);
   const locales = input.locales?.length ? input.locales : DEFAULT_LOCALES;
-  const provider = input.provider ?? "mock";
+  const provider = input.provider ?? "chatgpt-oauth";
   const preset = input.preset ?? "4:3";
   const imageQuality = input.imageQuality ?? "low";
   assertSupportedProvider(provider);
+  const chatGptOAuthCredential = provider === "chatgpt-oauth" ? resolveChatGptOAuthCredential(input.auth) : undefined;
   const modelConfig = resolveGenerationModelConfig(input.models, provider);
-  const llm = createLlmAdapter(provider, modelConfig.llm);
+  const llm = createLlmAdapter(provider, modelConfig.llm, chatGptOAuthCredential?.bearerToken);
   const stages: GenerationStage[] = [];
   const modelCalls: GenerationModelCall[] = [];
 
@@ -127,6 +136,7 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
     endpoint: llmEndpoint(provider),
     purpose: "readme_analysis",
     status: llmCallStatus(provider),
+    credentialSource: credentialSource(provider, chatGptOAuthCredential?.source),
   });
   const { primaryAsset } = resolveBrandAssets(repo, metadata, readme);
 
@@ -154,6 +164,7 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
     endpoint: llmEndpoint(provider),
     purpose: "launch_plan",
     status: llmCallStatus(provider),
+    credentialSource: credentialSource(provider, chatGptOAuthCredential?.source),
   });
   const { brief, visualDirection, layout, localizedCopy } = plan;
   const launchBrief = buildRepoLaunchBrief({
@@ -193,8 +204,14 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
       });
     }
     const generated =
-      provider === "openai"
-        ? await generateOpenAIImage(localeDir, locale, prompt, { preset })
+      provider === "chatgpt-oauth"
+        ? await generateOpenAIImage(localeDir, locale, prompt, {
+            preset,
+            apiKey: chatGptOAuthCredential?.bearerToken,
+            provider: "chatgpt-oauth",
+          })
+        : provider === "openai"
+          ? await generateOpenAIImage(localeDir, locale, prompt, { preset })
         : provider === "wavespeed"
           ? await generateWavespeedImage(localeDir, locale, prompt, { preset })
           : await generateMockImage(localeDir, locale, prompt);
@@ -233,6 +250,7 @@ export async function runProjectLaunchGeneration(input: CreateGenerationInput):
     endpoint: imageEndpoint(provider),
     purpose: "image_generation",
     status: imageCallStatus(provider, generationStatus),
+    credentialSource: credentialSource(provider, chatGptOAuthCredential?.source),
   });
   stages.push({
     id: "quality",
diff --git a/src/server/generation/types.ts b/src/server/generation/types.ts
index 0aa0e23..ab79a6d 100644
--- a/src/server/generation/types.ts
+++ b/src/server/generation/types.ts
@@ -1,5 +1,6 @@
 export type LocaleCode = "en" | "zh" | "ja";
-export type GenerationProvider = "mock" | "openai" | "wavespeed";
+export type GenerationProvider = "mock" | "chatgpt-oauth" | "openai" | "wavespeed";
+export type GenerationCredentialSource = "request_header" | "environment";
 export type OutputPreset =
   | "1:1"
   | "3:2"
@@ -282,6 +283,10 @@ export interface CreateGenerationInput {
   imageQuality?: ImageQuality;
   models?: Partial<GenerationModelConfig>;
   outputRoot?: string;
+  auth?: {
+    bearerToken: string;
+    source: GenerationCredentialSource;
+  };
   mock?: {
     repoMetadata?: Partial<GitHubRepoMetadata>;
     readmeMarkdown?: string;
@@ -311,6 +316,7 @@ export interface GenerationModelCall {
   endpoint?: string;
   purpose: "repository_source" | "readme_analysis" | "launch_plan" | "image_generation";
   status: "completed" | "failed" | "skipped";
+  credentialSource?: GenerationCredentialSource;
 }
 
 export interface GenerationResponse {