ima2-gen 1.1.7 → 1.1.9

package/routes/generate.ts

@@ -0,0 +1,309 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { randomBytes } from "crypto";
+import { summarizeReferencePayload, validateAndNormalizeRefs } from "../lib/refs.js";
+import { classifyUpstreamError } from "../lib/errorClassify.js";
+import { normalizeOAuthParams } from "../lib/oauthNormalize.js";
+import { resolveProviderOptions } from "../lib/providerOptions.js";
+import { generateViaResponses } from "../lib/responsesImageAdapter.js";
+import { isNonRetryableGenerationError, normalizeGenerationFailure } from "../lib/generationErrors.js";
+import { startJob, finishJob } from "../lib/inflight.js";
+import { logEvent, logError } from "../lib/logger.js";
+import { embedImageMetadataBestEffort } from "../lib/imageMetadataStore.js";
+
+function validateModeration(ctx, moderation) {
+  if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
+    return { error: "moderation must be one of: auto, low" };
+  }
+  return { moderation };
+}
+
+export function registerGenerateRoutes(app, ctx) {
+  app.post("/api/generate", async (req, res) => {
+    const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : req.id;
+    let finishStatus = "completed";
+    let finishHttpStatus;
+    let finishErrorCode;
+    let finishMeta = {};
+    try {
+      const sessionId = typeof req.body?.sessionId === "string" ? req.body.sessionId : null;
+      const clientNodeId = typeof req.body?.clientNodeId === "string" ? req.body.clientNodeId : null;
+      const {
+        prompt,
+        quality: rawQuality = "medium",
+        size = "1024x1024",
+        format = "png",
+        moderation = "low",
+        provider = "auto",
+        n = 1,
+        references = [],
+        mode: promptMode = "auto",
+        model: rawModel,
+        reasoningEffort: rawReasoningEffort,
+        webSearchEnabled: rawWebSearchEnabled = true,
+      } = req.body;
+      const { quality, warnings: qualityWarnings } = normalizeOAuthParams({ provider, quality: rawQuality });
+      const providerOptions = resolveProviderOptions(ctx, {
+        provider,
+        rawModel,
+        rawReasoningEffort,
+        rawSize: size,
+        rawWebSearchEnabled,
+      });
+      if (providerOptions.error) {
+        finishStatus = "error";
+        finishHttpStatus = providerOptions.status;
+        finishErrorCode = providerOptions.code;
+        return res.status(providerOptions.status).json({ error: providerOptions.error, code: providerOptions.code });
+      }
+      const imageModel = providerOptions.model;
+      const reasoningEffort = providerOptions.reasoningEffort;
+      const effectiveSize = providerOptions.size;
+      const webSearchEnabled = providerOptions.webSearchEnabled;
+      const activeProvider = providerOptions.provider;
+      const normalizedPromptMode = promptMode === "direct" ? "direct" : "auto";
+
+      if (!prompt) return res.status(400).json({ error: "Prompt is required" });
+      const moderationCheck = validateModeration(ctx, moderation);
+      if (moderationCheck.error) return res.status(400).json({ error: moderationCheck.error });
+      const count = Math.min(Math.max(parseInt(n) || 1, 1), 8);
+      const referencePayload = summarizeReferencePayload(references);
+
+      startJob({
+        requestId,
+        kind: "classic",
+        prompt,
+        meta: {
+          kind: "classic",
+          sessionId,
+          parentNodeId: null,
+          clientNodeId,
+          quality,
+          model: imageModel,
+          size: effectiveSize,
+          n: count,
+          refsCount: referencePayload.refsCount,
+          referenceBytes: referencePayload.referenceBytes,
+          referenceB64Chars: referencePayload.referenceB64Chars,
+        },
+      });
+
+      const refCheck = validateAndNormalizeRefs(references);
+      if (refCheck.error) {
+        finishStatus = "error";
+        finishHttpStatus = 400;
+        finishErrorCode = refCheck.code;
+        return res.status(400).json({ error: refCheck.error, code: refCheck.code });
+      }
+
+      const client = req.get("x-ima2-client") || "ui";
+      const referenceDiagnostics = refCheck.referenceDiagnostics || [];
+      const referenceMismatchCount = referenceDiagnostics.filter((ref) => ref.warnings?.includes("mime_mismatch")).length;
+      logEvent("generate", "request", {
+        requestId,
+        client,
+        provider: activeProvider,
+        quality,
+        model: imageModel,
+        size: effectiveSize,
+        moderation,
+        n: count,
+        refs: refCheck.refs.length,
+        referenceBytes: referencePayload.referenceBytes,
+        referenceMismatchCount,
+        refDetectedMimes: [...new Set(referenceDiagnostics.map((ref) => ref.detectedMime).filter(Boolean))].join(","),
+        refDeclaredMimes: [...new Set(referenceDiagnostics.map((ref) => ref.declaredMime).filter(Boolean))].join(","),
+        sessionId,
+        clientNodeId,
+        promptChars: typeof prompt === "string" ? prompt.length : 0,
+        promptMode: normalizedPromptMode,
+        webSearchEnabled,
+      });
+      const startTime = Date.now();
+
+      const mimeMap = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
+      const mime = mimeMap[format] || "image/png";
+      await mkdir(ctx.config.storage.generatedDir, { recursive: true });
+
+      const generateOne = async () => {
+        const MAX_RETRIES = 1;
+        let lastErr;
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+          try {
+            const r = await generateViaResponses(
+              activeProvider,
+              prompt,
+              quality,
+              effectiveSize,
+              moderation,
+              refCheck.refDetails || refCheck.refs,
+              requestId,
+              normalizedPromptMode,
+              ctx,
+              { model: imageModel, reasoningEffort, webSearchEnabled },
+            );
+            if (r.b64) return r;
+            lastErr = new Error("Empty response (safety refusal)");
+          } catch (e) {
+            lastErr = e;
+            if (isNonRetryableGenerationError(e)) break;
+          }
+          if (attempt < MAX_RETRIES) {
+            logEvent("generate", "retry", { requestId, attempt: attempt + 1, errorCode: lastErr?.code });
+          }
+        }
+        throw normalizeGenerationFailure(lastErr, {
+          safetyMessage: "Content generation refused after retries",
+        });
+      };
+
+      const results = await Promise.allSettled(Array.from({ length: count }, generateOne));
+      const images = [];
+      let totalUsage = null;
+      let totalWebSearchCalls = 0;
+      for (const r of results) {
+        if (r.status === "fulfilled" && r.value.b64) {
+          const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
+          const filename = `${Date.now()}_${rand}_${images.length}.${format}`;
+          const meta = {
+            kind: "classic",
+            requestId,
+            sessionId,
+            clientNodeId,
+            prompt,
+            userPrompt: prompt,
+            revisedPrompt: r.value.revisedPrompt || null,
+            promptMode: normalizedPromptMode,
+            quality,
+            size: effectiveSize,
+            format,
+            moderation,
+            model: imageModel,
+            provider: activeProvider,
+            createdAt: Date.now(),
+            usage: r.value.usage || null,
+            webSearchCalls: r.value.webSearchCalls || 0,
+            webSearchEnabled,
+            refsCount: refCheck.refs.length,
+          };
+          const rawBuffer = Buffer.from(r.value.b64, "base64");
+          const embedded: any = await embedImageMetadataBestEffort(rawBuffer, format, meta, {
+            version: ctx.packageVersion,
+          });
+          if (!embedded.embedded) {
+            logEvent("generate", "metadata_embed_skipped", {
+              requestId,
+              filename,
+              code: embedded.code,
+              warning: embedded.warning,
+            });
+          }
+          await writeFile(join(ctx.config.storage.generatedDir, filename), embedded.buffer);
+          await writeFile(join(ctx.config.storage.generatedDir, filename + ".json"), JSON.stringify(meta)).catch(() => {});
+          images.push({
+            image: `data:${mime};base64,${r.value.b64}`,
+            filename,
+            revisedPrompt: r.value.revisedPrompt || null,
+          });
+          if (r.value.usage) {
+            if (!totalUsage) totalUsage = { ...r.value.usage };
+            else Object.keys(r.value.usage).forEach((k) => {
+              if (typeof r.value.usage[k] === "number") totalUsage[k] = (totalUsage[k] || 0) + r.value.usage[k];
+            });
+          }
+          if (typeof r.value.webSearchCalls === "number") totalWebSearchCalls += r.value.webSearchCalls;
+        } else if (r.status === "rejected") {
+          logError("generate", "parallel_failed", r.reason, { requestId });
+        }
+      }
+
+      if (images.length === 0) {
+        const firstErr = results.find((r) => r.status === "rejected")?.reason;
+        if (firstErr?.code) {
+          const status = firstErr.status || 500;
+          finishStatus = "error";
+          finishHttpStatus = status;
+          finishErrorCode = firstErr.code;
+          return res.status(status).json({
+            error: firstErr.message,
+            code: firstErr.code,
+            upstreamCode: firstErr.upstreamCode || null,
+            upstreamType: firstErr.upstreamType || null,
+            upstreamParam: firstErr.upstreamParam || null,
+            diagnosticReason: firstErr.diagnosticReason || null,
+            retryKind: firstErr.retryKind || null,
+            referencesDroppedOnRetry: firstErr.referencesDroppedOnRetry ?? null,
+            errorEventCount: firstErr.eventCount ?? null,
+            requestId,
+          });
+        }
+        finishStatus = "error";
+        finishHttpStatus = 500;
+        finishErrorCode = "GENERATE_ALL_FAILED";
+        return res.status(500).json({ error: "All generation attempts failed" });
+      }
+
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      const firstRevised = images[0]?.revisedPrompt || null;
+      const extra = {
+        usage: totalUsage,
+        provider: activeProvider,
+        webSearchCalls: totalWebSearchCalls,
+        quality,
+        size: effectiveSize,
+        moderation,
+        model: imageModel,
+        warnings: qualityWarnings,
+        revisedPrompt: firstRevised,
+        promptMode: normalizedPromptMode,
+        webSearchEnabled,
+      };
+
+      if (count === 1) {
+        finishHttpStatus = 200;
+        finishMeta = { filenames: [images[0].filename], imageCount: 1 };
+        logEvent("generate", "saved", {
+          requestId,
+          imageCount: 1,
+          elapsedMs: Date.now() - startTime,
+          filename: images[0].filename,
+        });
+        res.json({ image: images[0].image, elapsed, filename: images[0].filename, requestId, ...extra });
+      } else {
+        finishHttpStatus = 200;
+        finishMeta = { filenames: images.map((image) => image.filename), imageCount: images.length };
+        logEvent("generate", "saved", {
+          requestId,
+          imageCount: images.length,
+          elapsedMs: Date.now() - startTime,
+        });
+        res.json({ images, elapsed, count: images.length, requestId, ...extra });
+      }
+    } catch (err) {
+      const fallbackCode = err.code || classifyUpstreamError(err.message);
+      finishStatus = "error";
+      finishHttpStatus = err.status || 500;
+      finishErrorCode = fallbackCode || "GENERATE_FAILED";
+      logError("generate", "error", err, { requestId, code: finishErrorCode });
+      res.status(err.status || 500).json({
+        error: err.message,
+        code: fallbackCode,
+        upstreamCode: err.upstreamCode || null,
+        upstreamType: err.upstreamType || null,
+        upstreamParam: err.upstreamParam || null,
+        diagnosticReason: err.diagnosticReason || null,
+        retryKind: err.retryKind || null,
+        referencesDroppedOnRetry: err.referencesDroppedOnRetry ?? null,
+        errorEventCount: err.eventCount ?? null,
+        requestId,
+      });
+    } finally {
+      finishJob(requestId, {
+        status: finishStatus,
+        httpStatus: finishHttpStatus,
+        errorCode: finishErrorCode,
+        meta: finishMeta,
+      });
+    }
+  });
+}

package/routes/health.js

@@ -1,113 +1,108 @@
 import { listJobs, listTerminalJobs, finishJob } from "../lib/inflight.js";
-
 export function registerHealthRoutes(app, ctx) {
-  const runtimePorts = () => ({
-    backend: {
-      configuredPort: Number(ctx.serverConfiguredPort || ctx.config.server.port),
-      actualPort: Number(ctx.serverActualPort || ctx.config.server.port),
-      url: ctx.serverUrl || `http://localhost:${ctx.serverActualPort || ctx.config.server.port}`,
-    },
-    oauth: {
-      configuredPort: Number(ctx.oauthPort),
-      actualPort: Number(ctx.oauthActualPort || ctx.oauthPort),
-      url: ctx.oauthUrl,
-      status: ctx.oauthReadyState,
-    },
-  });
-
-  app.get("/api/providers", (_req, res) => {
-    res.json({
-      apiKey: false,
-      oauth: true,
-      oauthPort: ctx.oauthPort,
-      oauthActualPort: ctx.oauthActualPort || ctx.oauthPort,
-      oauthUrl: ctx.oauthUrl,
-      apiKeyDisabled: true,
-      runtime: runtimePorts(),
+    const runtimePorts = () => ({
+        backend: {
+            configuredPort: Number(ctx.serverConfiguredPort || ctx.config.server.port),
+            actualPort: Number(ctx.serverActualPort || ctx.config.server.port),
+            url: ctx.serverUrl || `http://localhost:${ctx.serverActualPort || ctx.config.server.port}`,
+        },
+        oauth: {
+            configuredPort: Number(ctx.oauthPort),
+            actualPort: Number(ctx.oauthActualPort || ctx.oauthPort),
+            url: ctx.oauthUrl,
+            status: ctx.oauthReadyState,
+        },
     });
-  });
-
-  app.get("/api/health", (_req, res) => {
-    res.json({
-      ok: true,
-      version: ctx.packageVersion,
-      provider: "oauth",
-      uptimeSec: Math.round(process.uptime()),
-      activeJobs: listJobs().length,
-      pid: process.pid,
-      startedAt: ctx.startedAt,
-      runtime: runtimePorts(),
+    app.get("/api/providers", (_req, res) => {
+        res.json({
+            apiKey: Boolean(ctx.hasApiKey),
+            oauth: true,
+            oauthPort: ctx.oauthPort,
+            oauthActualPort: ctx.oauthActualPort || ctx.oauthPort,
+            oauthUrl: ctx.oauthUrl,
+            apiKeyDisabled: false,
+            apiKeySource: ctx.apiKeySource ?? "none",
+            runtime: runtimePorts(),
+        });
     });
-  });
-
-  app.get("/api/oauth/status", async (_req, res) => {
-    if (ctx.oauthReadyState === "starting") {
-      return res.json({ status: "starting", runtime: runtimePorts() });
-    }
-    if (ctx.oauthReadyState === "failed") {
-      return res.json({ status: "offline", runtime: runtimePorts() });
-    }
-    try {
-      const r = await fetch(`${ctx.oauthUrl}/v1/models`, {
-        signal: AbortSignal.timeout(ctx.config.oauth.statusTimeoutMs),
-      });
-      if (r.ok) {
-        const data = await r.json();
-        res.json({ status: "ready", models: data.data?.map((m) => m.id) || [], runtime: runtimePorts() });
-      } else {
-        res.json({ status: "auth_required", runtime: runtimePorts() });
-      }
-    } catch {
-      res.json({ status: "offline", runtime: runtimePorts() });
-    }
-  });
-
-  app.get("/api/inflight", (req, res) => {
-    const kind =
-      typeof req.query.kind === "string" && req.query.kind.length > 0
-        ? req.query.kind
-        : undefined;
-    const sessionId =
-      typeof req.query.sessionId === "string" && req.query.sessionId.length > 0
-        ? req.query.sessionId
-        : undefined;
-    const includeTerminal =
-      req.query.includeTerminal === "1" || req.query.includeTerminal === "true";
-    const jobs = listJobs({ kind, sessionId });
-    if (!includeTerminal) return res.json({ jobs });
-    return res.json({
-      jobs,
-      terminalJobs: listTerminalJobs({ kind, sessionId }),
+    app.get("/api/health", (_req, res) => {
+        res.json({
+            ok: true,
+            version: ctx.packageVersion,
+            provider: "oauth",
+            uptimeSec: Math.round(process.uptime()),
+            activeJobs: listJobs().length,
+            pid: process.pid,
+            startedAt: ctx.startedAt,
+            runtime: runtimePorts(),
+        });
+    });
+    app.get("/api/oauth/status", async (_req, res) => {
+        if (ctx.oauthReadyState === "starting") {
+            return res.json({ status: "starting", runtime: runtimePorts() });
+        }
+        if (ctx.oauthReadyState === "failed") {
+            return res.json({ status: "offline", runtime: runtimePorts() });
+        }
+        try {
+            const r = await fetch(`${ctx.oauthUrl}/v1/models`, {
+                signal: AbortSignal.timeout(ctx.config.oauth.statusTimeoutMs),
+            });
+            if (r.ok) {
+                const data = await r.json();
+                res.json({ status: "ready", models: data.data?.map((m) => m.id) || [], runtime: runtimePorts() });
+            }
+            else {
+                res.json({ status: "auth_required", runtime: runtimePorts() });
+            }
+        }
+        catch {
+            res.json({ status: "offline", runtime: runtimePorts() });
+        }
+    });
+    app.get("/api/inflight", (req, res) => {
+        const kind = typeof req.query.kind === "string" && req.query.kind.length > 0
+            ? req.query.kind
+            : undefined;
+        const sessionId = typeof req.query.sessionId === "string" && req.query.sessionId.length > 0
+            ? req.query.sessionId
+            : undefined;
+        const includeTerminal = req.query.includeTerminal === "1" || req.query.includeTerminal === "true";
+        const jobs = listJobs({ kind, sessionId });
+        if (!includeTerminal)
+            return res.json({ jobs });
+        return res.json({
+            jobs,
+            terminalJobs: listTerminalJobs({ kind, sessionId }),
+        });
+    });
+    app.delete("/api/inflight/:requestId", (req, res) => {
+        finishJob(req.params.requestId, { canceled: true });
+        res.status(204).end();
+    });
+    app.get("/api/billing", async (_req, res) => {
+        if (!ctx.hasApiKey) {
+            return res.json({ oauth: true, apiKeyValid: false, apiKeySource: "none" });
+        }
+        try {
+            const headers = { Authorization: `Bearer ${ctx.apiKey}`, "Content-Type": "application/json" };
+            const start = Math.floor(new Date(new Date().getFullYear(), new Date().getMonth(), 1).getTime() / 1000);
+            const end = Math.floor(Date.now() / 1000);
+            const [subRes, usageRes, modelsRes] = await Promise.allSettled([
+                fetch(`https://api.openai.com/v1/organization/costs?start_time=${start}&end_time=${end}&bucket_width=1d&limit=31`, { headers }),
+                fetch("https://api.openai.com/dashboard/billing/credit_grants", { headers }),
+                fetch("https://api.openai.com/v1/models", { headers }),
+            ]);
+            const billing = { apiKeySource: ctx.apiKeySource ?? "env" };
+            if (subRes.status === "fulfilled" && subRes.value.ok)
+                billing.costs = await subRes.value.json();
+            if (usageRes.status === "fulfilled" && usageRes.value.ok)
+                billing.credits = await usageRes.value.json();
+            billing.apiKeyValid = modelsRes.status === "fulfilled" && modelsRes.value.ok === true;
+            res.json(billing);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message, apiKeyValid: false });
+        }
     });
-  });
-
-  app.delete("/api/inflight/:requestId", (req, res) => {
-    finishJob(req.params.requestId, { canceled: true });
-    res.status(204).end();
-  });
-
-  app.get("/api/billing", async (_req, res) => {
-    if (!ctx.hasApiKey) {
-      return res.json({ oauth: true, apiKeyValid: false, apiKeySource: "none" });
-    }
-
-    try {
-      const headers = { Authorization: `Bearer ${ctx.apiKey}`, "Content-Type": "application/json" };
-      const start = Math.floor(new Date(new Date().getFullYear(), new Date().getMonth(), 1).getTime() / 1000);
-      const end = Math.floor(Date.now() / 1000);
-      const [subRes, usageRes, modelsRes] = await Promise.allSettled([
-        fetch(`https://api.openai.com/v1/organization/costs?start_time=${start}&end_time=${end}&bucket_width=1d&limit=31`, { headers }),
-        fetch("https://api.openai.com/dashboard/billing/credit_grants", { headers }),
-        fetch("https://api.openai.com/v1/models", { headers }),
-      ]);
-
-      const billing = { apiKeySource: ctx.apiKeySource ?? "env" };
-      if (subRes.status === "fulfilled" && subRes.value.ok) billing.costs = await subRes.value.json();
-      if (usageRes.status === "fulfilled" && usageRes.value.ok) billing.credits = await usageRes.value.json();
-      billing.apiKeyValid = modelsRes.status === "fulfilled" && modelsRes.value.ok === true;
-      res.json(billing);
-    } catch (err) {
-      res.status(500).json({ error: err.message, apiKeyValid: false });
-    }
-  });
 }

package/routes/health.ts

@@ -0,0 +1,114 @@
+import { listJobs, listTerminalJobs, finishJob } from "../lib/inflight.js";
+
+export function registerHealthRoutes(app, ctx) {
+  const runtimePorts = () => ({
+    backend: {
+      configuredPort: Number(ctx.serverConfiguredPort || ctx.config.server.port),
+      actualPort: Number(ctx.serverActualPort || ctx.config.server.port),
+      url: ctx.serverUrl || `http://localhost:${ctx.serverActualPort || ctx.config.server.port}`,
+    },
+    oauth: {
+      configuredPort: Number(ctx.oauthPort),
+      actualPort: Number(ctx.oauthActualPort || ctx.oauthPort),
+      url: ctx.oauthUrl,
+      status: ctx.oauthReadyState,
+    },
+  });
+
+  app.get("/api/providers", (_req, res) => {
+    res.json({
+      apiKey: Boolean(ctx.hasApiKey),
+      oauth: true,
+      oauthPort: ctx.oauthPort,
+      oauthActualPort: ctx.oauthActualPort || ctx.oauthPort,
+      oauthUrl: ctx.oauthUrl,
+      apiKeyDisabled: false,
+      apiKeySource: ctx.apiKeySource ?? "none",
+      runtime: runtimePorts(),
+    });
+  });
+
+  app.get("/api/health", (_req, res) => {
+    res.json({
+      ok: true,
+      version: ctx.packageVersion,
+      provider: "oauth",
+      uptimeSec: Math.round(process.uptime()),
+      activeJobs: listJobs().length,
+      pid: process.pid,
+      startedAt: ctx.startedAt,
+      runtime: runtimePorts(),
+    });
+  });
+
+  app.get("/api/oauth/status", async (_req, res) => {
+    if (ctx.oauthReadyState === "starting") {
+      return res.json({ status: "starting", runtime: runtimePorts() });
+    }
+    if (ctx.oauthReadyState === "failed") {
+      return res.json({ status: "offline", runtime: runtimePorts() });
+    }
+    try {
+      const r = await fetch(`${ctx.oauthUrl}/v1/models`, {
+        signal: AbortSignal.timeout(ctx.config.oauth.statusTimeoutMs),
+      });
+      if (r.ok) {
+        const data: any = await r.json();
+        res.json({ status: "ready", models: data.data?.map((m) => m.id) || [], runtime: runtimePorts() });
+      } else {
+        res.json({ status: "auth_required", runtime: runtimePorts() });
+      }
+    } catch {
+      res.json({ status: "offline", runtime: runtimePorts() });
+    }
+  });
+
+  app.get("/api/inflight", (req, res) => {
+    const kind =
+      typeof req.query.kind === "string" && req.query.kind.length > 0
+        ? req.query.kind
+        : undefined;
+    const sessionId =
+      typeof req.query.sessionId === "string" && req.query.sessionId.length > 0
+        ? req.query.sessionId
+        : undefined;
+    const includeTerminal =
+      req.query.includeTerminal === "1" || req.query.includeTerminal === "true";
+    const jobs = listJobs({ kind, sessionId });
+    if (!includeTerminal) return res.json({ jobs });
+    return res.json({
+      jobs,
+      terminalJobs: listTerminalJobs({ kind, sessionId }),
+    });
+  });
+
+  app.delete("/api/inflight/:requestId", (req, res) => {
+    finishJob(req.params.requestId, { canceled: true });
+    res.status(204).end();
+  });
+
+  app.get("/api/billing", async (_req, res) => {
+    if (!ctx.hasApiKey) {
+      return res.json({ oauth: true, apiKeyValid: false, apiKeySource: "none" });
+    }
+
+    try {
+      const headers = { Authorization: `Bearer ${ctx.apiKey}`, "Content-Type": "application/json" };
+      const start = Math.floor(new Date(new Date().getFullYear(), new Date().getMonth(), 1).getTime() / 1000);
+      const end = Math.floor(Date.now() / 1000);
+      const [subRes, usageRes, modelsRes] = await Promise.allSettled([
+        fetch(`https://api.openai.com/v1/organization/costs?start_time=${start}&end_time=${end}&bucket_width=1d&limit=31`, { headers }),
+        fetch("https://api.openai.com/dashboard/billing/credit_grants", { headers }),
+        fetch("https://api.openai.com/v1/models", { headers }),
+      ]);
+
+      const billing: any = { apiKeySource: ctx.apiKeySource ?? "env" };
+      if (subRes.status === "fulfilled" && subRes.value.ok) billing.costs = await subRes.value.json();
+      if (usageRes.status === "fulfilled" && usageRes.value.ok) billing.credits = await usageRes.value.json();
+      billing.apiKeyValid = modelsRes.status === "fulfilled" && modelsRes.value.ok === true;
+      res.json(billing);
+    } catch (err) {
+      res.status(500).json({ error: err.message, apiKeyValid: false });
+    }
+  });
+}