ima2-gen 1.1.21 → 1.1.23

package/routes/generate.ts

@@ -1,492 +0,0 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { join } from "path";
-import { randomBytes } from "crypto";
-import type { Express, Request, Response } from "express";
-import { detectImageMimeFromB64, 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 { generateViaGrok, planGrokImage } from "../lib/grokImageAdapter.js";
-import { isNonRetryableGenerationError, normalizeGenerationFailure, type UpstreamErr } from "../lib/generationErrors.js";
-import { startJob, finishJob, registerJobAbortController, isJobCanceled } from "../lib/inflight.js";
-import {
-  isGenerationCanceledError,
-  makeGenerationCanceledError,
-  throwIfJobCanceled,
-} from "../lib/generationCancel.js";
-import { logEvent, logError } from "../lib/logger.js";
-import { embedImageMetadataBestEffort } from "../lib/imageMetadataStore.js";
-import { invalidateHistoryIndex } from "../lib/historyIndex.js";
-import {
-  normalizeComposerInsertedPrompts,
-  normalizeComposerPrompt,
-} from "../lib/composerSnapshot.js";
-
-import { errInfo } from "../lib/errInfo.js";
-import { requireRuntimeContext, type RouteRuntimeContext, type RuntimeContext } from "../lib/runtimeContext.js";
-function validateModeration(ctx: RuntimeContext, moderation: unknown) {
-  if (typeof moderation !== "string" || !ctx.config.oauth.validModeration.has(moderation)) {
-    return { error: "moderation must be one of: auto, low" };
-  }
-  return { moderation };
-}
-
-function imageFormatFromMime(mime: string | null | undefined): "png" | "jpeg" | "webp" {
-  if (mime === "image/jpeg") return "jpeg";
-  if (mime === "image/webp") return "webp";
-  return "png";
-}
-
-export function registerGenerateRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  app.post("/api/generate", async (req: Request, res: Response) => {
-    const requestId = typeof req.body?.requestId === "string" ? req.body.requestId : req.id;
-    let finishStatus = "completed";
-    let finishHttpStatus;
-    let finishErrorCode;
-    let finishMeta = {};
-    let finishCanceled = false;
-    const cancelController = new AbortController();
-    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 composerPrompt = normalizeComposerPrompt(req.body?.composerPrompt);
-      const composerInsertedPrompts = normalizeComposerInsertedPrompts(
-        req.body?.composerInsertedPrompts,
-      );
-      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,
-          composerPrompt,
-          composerInsertedPrompts,
-        },
-      });
-      registerJobAbortController(requestId, cancelController);
-
-      const refCheckResult = validateAndNormalizeRefs(references);
-      if (refCheckResult.error) {
-        finishStatus = "error";
-        finishHttpStatus = 400;
-        finishErrorCode = refCheckResult.code;
-        return res.status(400).json({ error: refCheckResult.error, code: refCheckResult.code });
-      }
-      const refCheck = refCheckResult as Extract<typeof refCheckResult, { refs: string[] }>;
-      if (activeProvider === "grok" && refCheck.refs.length > 3) {
-        finishStatus = "error";
-        finishHttpStatus = 400;
-        finishErrorCode = "GROK_REF_TOO_MANY";
-        return res.status(400).json({
-          error: "Grok image editing supports up to 3 reference images",
-          code: "GROK_REF_TOO_MANY",
-          requestId,
-        });
-      }
-
-      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: Record<string, string> = { png: "image/png", jpeg: "image/jpeg", webp: "image/webp" };
-      const effectiveFormat = activeProvider === "grok" ? "jpeg" : String(format);
-      const mime = mimeMap[effectiveFormat] || "image/png";
-      await mkdir(ctx.config.storage.generatedDir, { recursive: true });
-
-      const sharedGrokPlan = activeProvider === "grok"
-        ? await planGrokImage(prompt, ctx, {
-          model: quality === "high" ? "grok-imagine-image-quality" : imageModel,
-          size: effectiveSize,
-          signal: cancelController.signal,
-          requestId,
-          referenceCount: refCheck.refs.length,
-          references: refCheck.refDetails,
-        })
-        : null;
-
-      const generateOne = async () => {
-        if (activeProvider === "grok") {
-          const grokModel = quality === "high" ? "grok-imagine-image-quality" : imageModel;
-          const r = await generateViaGrok(prompt, ctx, {
-            model: grokModel,
-            size: effectiveSize,
-            signal: cancelController.signal,
-            requestId,
-            plannedPrompt: sharedGrokPlan?.prompt,
-            webSearchCalls: sharedGrokPlan?.webSearchCalls,
-            references: refCheck.refDetails,
-          });
-          throwIfJobCanceled(requestId);
-          return r;
-        }
-
-        const MAX_RETRIES = 1;
-        let lastErr: unknown;
-        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,
-                signal: cancelController.signal,
-                allowPromptOnlyOAuthFallback: activeProvider !== "api",
-              },
-            );
-            throwIfJobCanceled(requestId);
-            if (r.b64) return r;
-            lastErr = new Error("Empty response (safety refusal)");
-          } catch (e) {
-            lastErr = e;
-            if (isNonRetryableGenerationError(e as UpstreamErr | null | undefined)) break;
-          }
-          if (attempt < MAX_RETRIES) {
-            const errCode = (lastErr && typeof lastErr === "object" && "code" in lastErr)
-              ? (lastErr as { code?: unknown }).code
-              : undefined;
-            logEvent("generate", "retry", { requestId, attempt: attempt + 1, errorCode: errCode });
-          }
-        }
-        throw normalizeGenerationFailure(lastErr as UpstreamErr | null | undefined, {
-          safetyMessage: "Content generation refused after retries",
-        });
-      };
-
-      const results = await Promise.allSettled(Array.from({ length: count }, generateOne));
-      throwIfJobCanceled(requestId);
-      const images: Array<{ image: string; filename: string; revisedPrompt: any }> = [];
-      let totalUsage: Record<string, number> | null = null;
-      let totalWebSearchCalls = 0;
-      let firstRetryMeta: Record<string, unknown> | null = null;
-      for (const r of results) {
-        if (r.status === "fulfilled" && r.value.b64) {
-          throwIfJobCanceled(requestId);
-          const valueWithMime = r.value as typeof r.value & { mime?: string };
-          const resultMime = activeProvider === "grok"
-            ? (valueWithMime.mime || detectImageMimeFromB64(r.value.b64) || mime)
-            : mime;
-          const resultFormat = activeProvider === "grok" ? imageFormatFromMime(resultMime) : effectiveFormat;
-          const retryValue = r.value as typeof r.value & {
-            retryKind?: string;
-            initialEventCount?: number;
-            initialEventTypes?: unknown;
-            referencesDroppedOnRetry?: boolean;
-            developerPromptDroppedOnRetry?: boolean;
-            webSearchDroppedOnRetry?: boolean;
-          };
-          if (!firstRetryMeta && retryValue.retryKind) {
-            firstRetryMeta = {
-              retryKind: retryValue.retryKind,
-              initialEventCount: retryValue.initialEventCount ?? null,
-              initialEventTypes: retryValue.initialEventTypes || null,
-              referencesDroppedOnRetry: retryValue.referencesDroppedOnRetry ?? null,
-              developerPromptDroppedOnRetry: retryValue.developerPromptDroppedOnRetry ?? null,
-              webSearchDroppedOnRetry: retryValue.webSearchDroppedOnRetry ?? null,
-            };
-          }
-          const rand = randomBytes(ctx.config.ids.generatedHexBytes).toString("hex");
-          const filename = `${Date.now()}_${rand}_${images.length}.${resultFormat}`;
-          const meta = {
-            kind: "classic",
-            requestId,
-            sessionId,
-            clientNodeId,
-            prompt,
-            userPrompt: prompt,
-            revisedPrompt: r.value.revisedPrompt || null,
-            promptMode: normalizedPromptMode,
-            composerPrompt,
-            composerInsertedPrompts,
-            quality,
-            size: effectiveSize,
-            format: resultFormat,
-            moderation,
-            model: activeProvider === "grok" ? (quality === "high" ? "grok-imagine-image-quality" : imageModel) : imageModel,
-            reasoningEffort,
-            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, resultFormat, 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(() => {});
-          invalidateHistoryIndex();
-          images.push({
-            image: `data:${resultMime};base64,${r.value.b64}`,
-            filename,
-            revisedPrompt: r.value.revisedPrompt || null,
-          });
-          if (r.value.usage) {
-            const usageValue = r.value.usage;
-            if (!totalUsage) totalUsage = { ...usageValue };
-            else {
-              const tu = totalUsage;
-              Object.keys(usageValue).forEach((k) => {
-                if (typeof usageValue[k] === "number") tu[k] = (tu[k] || 0) + usageValue[k];
-              });
-            }
-          }
-          if (typeof r.value.webSearchCalls === "number") {
-            totalWebSearchCalls = activeProvider === "grok"
-              ? Math.max(totalWebSearchCalls, r.value.webSearchCalls)
-              : 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;
-          if (isGenerationCanceledError(firstErr)) {
-            finishCanceled = true;
-            finishHttpStatus = firstErr.status;
-            finishErrorCode = firstErr.code;
-            return res.status(firstErr.status).json({
-              error: firstErr.message,
-              code: firstErr.code,
-              requestId,
-            });
-          }
-          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,
-            initialEventCount: firstErr.initialEventCount ?? null,
-            initialEventTypes: firstErr.initialEventTypes || null,
-            referencesDroppedOnRetry: firstErr.referencesDroppedOnRetry ?? null,
-            developerPromptDroppedOnRetry: firstErr.developerPromptDroppedOnRetry ?? null,
-            webSearchDroppedOnRetry: firstErr.webSearchDroppedOnRetry ?? null,
-            fallbackEventCount: firstErr.fallbackEventCount ?? null,
-            fallbackEventTypes: firstErr.fallbackEventTypes || null,
-            fallbackImageCallSeen: firstErr.fallbackImageCallSeen ?? null,
-            fallbackImageResultCount: firstErr.fallbackImageResultCount ?? null,
-            errorEventCount: firstErr.eventCount ?? null,
-            eventTypes: firstErr.eventTypes || null,
-            webSearchCalls: firstErr.webSearchCalls ?? null,
-            responseDiagnostics: firstErr.responseDiagnostics || null,
-            toolTypes: firstErr.toolTypes || null,
-            toolChoiceKind: firstErr.toolChoiceKind || 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);
-      // Persist elapsed (computed after the generation loop) into each image's sidecar.
-      // forward-fix: only newly generated items get elapsed. The embedded XMP is written
-      // earlier in the loop (before elapsed exists), so history reload relies on this sidecar patch.
-      await Promise.all(
-        images.map(async ({ filename }) => {
-          try {
-            const sidecarPath = join(ctx.config.storage.generatedDir, filename + ".json");
-            const sidecarMeta = JSON.parse(await readFile(sidecarPath, "utf-8"));
-            sidecarMeta.elapsed = elapsed;
-            await writeFile(sidecarPath, JSON.stringify(sidecarMeta));
-          } catch {
-            /* best-effort, matches the sidecar write .catch(() => {}) above */
-          }
-        }),
-      );
-      const firstRevised = images[0]?.revisedPrompt || null;
-      const extra = {
-        usage: totalUsage,
-        provider: activeProvider,
-        reasoningEffort,
-        webSearchCalls: totalWebSearchCalls,
-        quality,
-        size: effectiveSize,
-        moderation,
-        model: imageModel,
-        warnings: qualityWarnings,
-        revisedPrompt: firstRevised,
-        promptMode: normalizedPromptMode,
-        webSearchEnabled,
-        ...(firstRetryMeta || {}),
-      };
-
-      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 (e) {
-      const err = errInfo(e);
-      const ext = (err.raw && typeof err.raw === "object" ? err.raw as Record<string, unknown> : {});
-      const fallbackCode = err.code || classifyUpstreamError(err.message);
-      if (isGenerationCanceledError(err.raw) || isJobCanceled(requestId)) {
-        const canceled = makeGenerationCanceledError();
-        finishCanceled = true;
-        finishHttpStatus = canceled.status;
-        finishErrorCode = canceled.code;
-        return res.status(canceled.status).json({
-          error: canceled.message,
-          code: canceled.code,
-          requestId,
-        });
-      }
-      finishStatus = "error";
-      finishHttpStatus = err.status || 500;
-      finishErrorCode = fallbackCode || "GENERATE_FAILED";
-      logError("generate", "error", err.raw, { requestId, code: finishErrorCode });
-      res.status(err.status || 500).json({
-        error: err.message,
-        code: fallbackCode,
-        upstreamCode: ext.upstreamCode || null,
-        upstreamType: ext.upstreamType || null,
-        upstreamParam: ext.upstreamParam || null,
-        diagnosticReason: ext.diagnosticReason || null,
-        retryKind: ext.retryKind || null,
-        initialEventCount: ext.initialEventCount ?? null,
-        initialEventTypes: ext.initialEventTypes || null,
-        referencesDroppedOnRetry: ext.referencesDroppedOnRetry ?? null,
-        developerPromptDroppedOnRetry: ext.developerPromptDroppedOnRetry ?? null,
-        webSearchDroppedOnRetry: ext.webSearchDroppedOnRetry ?? null,
-        fallbackEventCount: ext.fallbackEventCount ?? null,
-        fallbackEventTypes: ext.fallbackEventTypes || null,
-        fallbackImageCallSeen: ext.fallbackImageCallSeen ?? null,
-        fallbackImageResultCount: ext.fallbackImageResultCount ?? null,
-        errorEventCount: ext.eventCount ?? null,
-        eventTypes: ext.eventTypes || null,
-        webSearchCalls: ext.webSearchCalls ?? null,
-        responseDiagnostics: ext.responseDiagnostics || null,
-        toolTypes: ext.toolTypes || null,
-        toolChoiceKind: ext.toolChoiceKind || null,
-        requestId,
-      });
-    } finally {
-      finishJob(requestId, {
-        canceled: finishCanceled,
-        status: finishStatus,
-        httpStatus: finishHttpStatus,
-        errorCode: finishErrorCode,
-        meta: finishMeta,
-      });
-    }
-  });
-}

package/routes/grok.ts

@@ -1,24 +0,0 @@
-import type { Express } from "express";
-import type { RouteRuntimeContext } from "../lib/runtimeContext.js";
-import { getGrokProxyUrl } from "../lib/grokRuntime.js";
-
-export function registerGrokRoutes(app: Express, ctx: RouteRuntimeContext) {
-  app.get("/api/grok/status", async (_req, res) => {
-    const grokCfg = (ctx.config as any).grokProvider || {};
-    const timeoutMs = grokCfg.statusTimeoutMs || 3000;
-    try {
-      const r = await fetch(getGrokProxyUrl(ctx, "/v1/models"), {
-        signal: AbortSignal.timeout(timeoutMs),
-      });
-      if (r.ok) {
-        const data: any = await r.json();
-        const models: string[] = data?.data?.map((m: any) => m.id).filter(Boolean) || [];
-        const hasImageModel = models.some((m: string) => m.startsWith("grok-imagine"));
-        return res.json({ status: hasImageModel ? "ready" : "no_image_model", models });
-      }
-      return res.json({ status: "error", reason: `HTTP ${r.status}` });
-    } catch {
-      return res.json({ status: "offline" });
-    }
-  });
-}

package/routes/health.ts

@@ -1,123 +0,0 @@
-import type { Express, Request, Response } from "express";
-import { abortJob, listJobs, listTerminalJobs } from "../lib/inflight.js";
-
-import { errInfo } from "../lib/errInfo.js";
-import { requireRuntimeContext, type RouteRuntimeContext } from "../lib/runtimeContext.js";
-export function registerHealthRoutes(app: Express, ctxRaw: RouteRuntimeContext) {
-  const ctx = requireRuntimeContext(ctxRaw);
-  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,
-    },
-    grok: {
-      configuredPort: Number(ctx.grokPort),
-      actualPort: Number(ctx.grokActualPort || ctx.grokPort),
-      url: ctx.grokUrl,
-    },
-  });
-
-  app.get("/api/providers", (_req: Request, res: Response) => {
-    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: Request, res: Response) => {
-    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: Request, res: Response) => {
-    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()) as { data?: Array<{ id: string }> };
-        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: Request, res: Response) => {
-    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: Request<{ requestId: string }>, res: Response) => {
-    res.json(abortJob(req.params.requestId));
-  });
-
-  app.get("/api/billing", async (_req: Request, res: Response) => {
-    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: Record<string, unknown> = { 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 (e) {
-      const err = errInfo(e);
-      res.status(500).json({ error: err.message, apiKeyValid: false });
-    }
-  });
-}