ima2-gen 1.1.21 → 1.1.23

package/lib/refs.ts

@@ -1,133 +0,0 @@
-// lib/refs.js — reference-image validator (0.09.7).
-// Extracted from server.js so unit tests can import without booting the app.
-
-import { config } from "../config.js";
-
-const BASE64_RE = /^[A-Za-z0-9+/]+=*$/;
-const DATA_URL_RE = /^data:([^;,]+);base64,/i;
-
-function approxBase64Bytes(b64: string) {
-  try {
-    return Buffer.from(b64, "base64").length;
-  } catch {
-    return Math.floor((b64.length * 3) / 4);
-  }
-}
-
-export function detectImageMimeFromB64(b64: string | null | undefined) {
-  if (!b64) return null;
-  let buf: Buffer;
-  try {
-    buf = Buffer.from(b64, "base64");
-  } catch {
-    return null;
-  }
-  if (buf.length >= 4 && buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
-    return "image/png";
-  }
-  if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
-    return "image/jpeg";
-  }
-  if (
-    buf.length >= 12 &&
-    buf.toString("ascii", 0, 4) === "RIFF" &&
-    buf.toString("ascii", 8, 12) === "WEBP"
-  ) {
-    return "image/webp";
-  }
-  return null;
-}
-
-export function safeReferenceDiagnostics(refDetails: any[] = []) {
-  if (!Array.isArray(refDetails)) return [];
-  return refDetails.map((ref: any) => ({
-    index: ref.index,
-    declaredMime: ref.declaredMime || null,
-    detectedMime: ref.detectedMime || null,
-    b64Chars: ref.b64Chars,
-    approxBytes: ref.approxBytes,
-    source: ref.source,
-    warnings: ref.warnings || [],
-  }));
-}
-
-export function summarizeReferencePayload(references: unknown) {
-  if (!Array.isArray(references)) {
-    return { refsCount: 0, referenceBytes: 0, referenceB64Chars: 0 };
-  }
-  let referenceBytes = 0;
-  let referenceB64Chars = 0;
-  for (const ref of references) {
-    if (typeof ref !== "string") continue;
-    const b64 = ref.replace(DATA_URL_RE, "");
-    referenceB64Chars += b64.length;
-    referenceBytes += approxBase64Bytes(b64);
-  }
-  return {
-    refsCount: references.length,
-    referenceBytes,
-    referenceB64Chars,
-  };
-}
-
-type RefDetail = {
-  index: number;
-  b64: string;
-  declaredMime: string | null;
-  detectedMime: string | null;
-  b64Chars: number;
-  approxBytes: number;
-  source: string;
-  warnings: string[];
-};
-
-type RefsValidationResult =
-  | { error: string; code: string; refs?: undefined; refDetails?: undefined; referenceDiagnostics?: undefined }
-  | { error?: undefined; code?: undefined; refs: string[]; refDetails: RefDetail[]; referenceDiagnostics: ReturnType<typeof safeReferenceDiagnostics> };
-
-export function validateAndNormalizeRefs(references: unknown, {
-  maxCount = config.limits.maxRefCount,
-  maxB64Bytes = config.limits.maxRefB64Bytes,
-} = {}): RefsValidationResult {
-  if (!Array.isArray(references)) {
-    return { error: "references must be an array", code: "REF_NOT_ARRAY" };
-  }
-  if (references.length > maxCount) {
-    return { error: `references may not exceed ${maxCount} items`, code: "REF_TOO_MANY" };
-  }
-  const out: string[] = [];
-  const refDetails: RefDetail[] = [];
-  for (let i = 0; i < references.length; i++) {
-    const r = references[i];
-    if (typeof r !== "string") {
-      return { error: `references[${i}] must be a string`, code: "REF_NOT_STRING" };
-    }
-    const dataUrlMatch = r.match(DATA_URL_RE);
-    const declaredMime = dataUrlMatch?.[1]?.toLowerCase() || null;
-    const b64 = r.replace(DATA_URL_RE, "");
-    if (!b64) return { error: `references[${i}] is empty`, code: "REF_EMPTY" };
-    if (b64.length > maxB64Bytes) {
-      return { error: `references[${i}] exceeds ${maxB64Bytes} bytes`, code: "REF_TOO_LARGE" };
-    }
-    if (!BASE64_RE.test(b64)) {
-      return { error: `references[${i}] is not valid base64`, code: "REF_NOT_BASE64" };
-    }
-    const detectedMime = detectImageMimeFromB64(b64);
-    const warnings: string[] = [];
-    if (declaredMime && detectedMime && declaredMime !== detectedMime) {
-      warnings.push("mime_mismatch");
-    }
-    out.push(b64);
-    refDetails.push({
-      index: i,
-      b64,
-      declaredMime,
-      detectedMime,
-      b64Chars: b64.length,
-      approxBytes: approxBase64Bytes(b64),
-      source: declaredMime ? "dataUrl" : "rawBase64",
-      warnings,
-    });
-  }
-  return { refs: out, refDetails, referenceDiagnostics: safeReferenceDiagnostics(refDetails) };
-}

package/lib/requestLogger.ts

@@ -1,49 +0,0 @@
-import { randomUUID } from "crypto";
-import type { Request, Response, NextFunction } from "express";
-import { logEvent } from "./logger.js";
-
-const REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
-const IGNORED_LOG_PATHS = new Set(["/api/health", "/api/inflight"]);
-
-export function normalizeRequestId(value: unknown) {
-  return typeof value === "string" && REQUEST_ID_RE.test(value) ? value : `req_${randomUUID()}`;
-}
-
-function requestPath(req: Request) {
-  return String(req.originalUrl || req.url || "").split("?")[0] || "/";
-}
-
-export function createRequestLogger() {
-  return function requestLogger(req: Request, res: Response, next: NextFunction) {
-    const path = requestPath(req);
-    if (!path.startsWith("/api/")) return next();
-
-    const requestId = normalizeRequestId(req.get("x-request-id"));
-    const startedAt = Date.now();
-    req.id = requestId;
-    res.setHeader("X-Request-Id", requestId);
-
-    const ignoreLog = IGNORED_LOG_PATHS.has(path);
-    if (!ignoreLog) {
-      logEvent("http", "request", {
-        requestId,
-        method: req.method,
-        path,
-        client: req.get("x-ima2-client") || "ui",
-      });
-    }
-
-    res.on("finish", () => {
-      if (ignoreLog) return;
-      logEvent("http", "response", {
-        requestId,
-        method: req.method,
-        path,
-        status: res.statusCode,
-        durationMs: Date.now() - startedAt,
-      });
-    });
-
-    next();
-  };
-}

package/lib/responsesDoctor.ts

@@ -1,456 +0,0 @@
-import { config as defaultConfig } from "../config.js";
-import { errInfo } from "./errInfo.js";
-import { parseJson, parseStream, safeDiagnosticLabel, type ResponseDiagnostics } from "./responsesParse.js";
-import type { RouteRuntimeContext } from "./runtimeContext.js";
-import {
-  GENERATE_DEVELOPER_PROMPT,
-  GENERATE_NO_SEARCH_DEVELOPER_PROMPT,
-  buildUserTextPrompt,
-  waitForOAuthReady,
-} from "./oauthProxy.js";
-
-type ToolChoiceSummary = "none" | "required" | "image_generation";
-type ProbeExpectation = "text" | "image";
-
-interface ProbeSpec {
-  id: string;
-  expectation: ProbeExpectation;
-  promptId: string;
-  promptChars: number;
-  stream: boolean;
-  toolTypes: string[];
-  toolChoiceKind: ToolChoiceSummary;
-  payload: Record<string, unknown>;
-}
-
-export interface ImageDoctorProbeOptions {
-  provider?: string;
-  apiKey?: string;
-  oauthUrl?: string;
-  model?: string;
-  size?: string;
-  quality?: string;
-  moderation?: string;
-  prompt?: string;
-  matrix?: boolean;
-  timeoutMs?: number;
-  ctx?: RouteRuntimeContext;
-}
-
-export interface ImageDoctorProbeResult {
-  id: string;
-  ok: boolean;
-  expectation: ProbeExpectation;
-  diagnosticReason: string | null;
-  request: {
-    stream: boolean;
-    toolTypes: string[];
-    toolChoiceKind: ToolChoiceSummary;
-    promptId: string;
-    promptChars: number;
-  };
-  response: {
-    httpStatus: number | null;
-    contentType: string | null;
-    upstreamRequestId: string | null;
-    durationMs: number;
-    eventCount: number;
-    eventTypes: Record<string, number>;
-    webSearchCalls: number;
-    textOutputChars: number;
-    imageResultCount: number;
-    firstImageChars: number;
-    diagnostics: ResponseDiagnostics | null;
-  };
-  error: {
-    code: string | null;
-    type: string | null;
-    param: string | null;
-    message: string;
-    upstreamBodyChars?: number;
-  } | null;
-}
-
-const BUILTIN_PROMPT_ID = "builtin_cat";
-const BUILTIN_CAT_PROMPT = "고양이";
-const TEXT_OK_PROMPT = "Reply with exactly OK.";
-
-function imageTool(size: string, quality: string, moderation: string) {
-  return { type: "image_generation", size, quality, moderation, action: "generate" };
-}
-
-function createProbeSpecs({
-  model,
-  size,
-  quality,
-  moderation,
-  prompt,
-  matrix,
-}: Required<Pick<ImageDoctorProbeOptions, "model" | "size" | "quality" | "moderation" | "prompt">> & { matrix: boolean }): ProbeSpec[] {
-  const imageOnlyTools = [imageTool(size, quality, moderation)];
-  const webSearchImageTools = [{ type: "web_search" }, imageTool(size, quality, moderation)];
-  const specs: ProbeSpec[] = [
-    {
-      id: "text_sanity",
-      expectation: "text",
-      promptId: "builtin_text_ok",
-      promptChars: TEXT_OK_PROMPT.length,
-      stream: false,
-      toolTypes: [],
-      toolChoiceKind: "none",
-      payload: {
-        model,
-        input: [{ role: "user", content: TEXT_OK_PROMPT }],
-        stream: false,
-      },
-    },
-    {
-      id: "minimal_image_non_stream",
-      expectation: "image",
-      promptId: BUILTIN_PROMPT_ID,
-      promptChars: prompt.length,
-      stream: false,
-      toolTypes: ["image_generation"],
-      toolChoiceKind: "image_generation",
-      payload: {
-        model,
-        input: [{ role: "user", content: prompt }],
-        tools: imageOnlyTools,
-        tool_choice: { type: "image_generation" },
-        stream: false,
-      },
-    },
-    {
-      id: "minimal_image_stream",
-      expectation: "image",
-      promptId: BUILTIN_PROMPT_ID,
-      promptChars: prompt.length,
-      stream: true,
-      toolTypes: ["image_generation"],
-      toolChoiceKind: "image_generation",
-      payload: {
-        model,
-        input: [{ role: "user", content: prompt }],
-        tools: imageOnlyTools,
-        tool_choice: { type: "image_generation" },
-        stream: true,
-      },
-    },
-  ];
-  if (!matrix) return specs;
-  return [
-    ...specs,
-    {
-      id: "current_payload_no_search_required",
-      expectation: "image",
-      promptId: BUILTIN_PROMPT_ID,
-      promptChars: prompt.length,
-      stream: true,
-      toolTypes: ["image_generation"],
-      toolChoiceKind: "required",
-      payload: {
-        model,
-        input: [
-          { role: "developer", content: GENERATE_NO_SEARCH_DEVELOPER_PROMPT },
-          { role: "user", content: buildUserTextPrompt(prompt, "auto", { webSearchEnabled: false }) },
-        ],
-        tools: imageOnlyTools,
-        tool_choice: "required",
-        reasoning: { effort: "low" },
-        stream: true,
-      },
-    },
-    {
-      id: "current_payload_web_search_required",
-      expectation: "image",
-      promptId: BUILTIN_PROMPT_ID,
-      promptChars: prompt.length,
-      stream: true,
-      toolTypes: ["web_search", "image_generation"],
-      toolChoiceKind: "required",
-      payload: {
-        model,
-        input: [
-          { role: "developer", content: GENERATE_DEVELOPER_PROMPT },
-          { role: "user", content: buildUserTextPrompt(prompt, "auto", { webSearchEnabled: true }) },
-        ],
-        tools: webSearchImageTools,
-        tool_choice: "required",
-        reasoning: { effort: "low" },
-        stream: true,
-      },
-    },
-    {
-      id: "current_payload_web_search_forced_image",
-      expectation: "image",
-      promptId: BUILTIN_PROMPT_ID,
-      promptChars: prompt.length,
-      stream: true,
-      toolTypes: ["web_search", "image_generation"],
-      toolChoiceKind: "image_generation",
-      payload: {
-        model,
-        input: [
-          { role: "developer", content: GENERATE_DEVELOPER_PROMPT },
-          { role: "user", content: buildUserTextPrompt(prompt, "auto", { webSearchEnabled: true }) },
-        ],
-        tools: webSearchImageTools,
-        tool_choice: { type: "image_generation" },
-        reasoning: { effort: "low" },
-        stream: true,
-      },
-    },
-  ];
-}
-
-async function endpointFor(provider: string, options: ImageDoctorProbeOptions) {
-  const ctx = options.ctx || { config: defaultConfig };
-  if (provider === "api") {
-    const headers: Record<string, string> = {
-      "Content-Type": "application/json",
-      Accept: "text/event-stream, application/json",
-      Authorization: apiAuthorizationHeader(options.apiKey),
-    };
-    return {
-      url: "https://api.openai.com/v1/responses",
-      headers,
-    };
-  }
-  await waitForOAuthReady(ctx);
-  const port = ctx.config?.oauth?.proxyPort || defaultConfig.oauth.proxyPort;
-  const baseUrl = safeOAuthBaseUrl(options.oauthUrl || `http://127.0.0.1:${port}`);
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    Accept: "text/event-stream, application/json",
-  };
-  return {
-    url: `${baseUrl}/v1/responses`,
-    headers,
-  };
-}
-
-function apiAuthorizationHeader(apiKey: string | undefined) {
-  const key = typeof apiKey === "string" ? apiKey.trim() : "";
-  if (!key) {
-    throw Object.assign(new Error("API key is required for API provider image probe"), {
-      code: "API_KEY_REQUIRED",
-    });
-  }
-  if (/[\u0000-\u001f\u007f]/.test(key)) {
-    throw Object.assign(new Error("API key contains invalid characters."), {
-      code: "AUTH_API_KEY_INVALID",
-    });
-  }
-  return `Bearer ${key}`;
-}
-
-function safeOAuthBaseUrl(value: string) {
-  try {
-    const parsed = new URL(value);
-    parsed.username = "";
-    parsed.password = "";
-    return parsed.toString().replace(/\/$/, "");
-  } catch {
-    return value.replace(/\/$/, "");
-  }
-}
-
-function sanitizeProbeErrorMessage(value: string) {
-  return value
-    .replace(/([a-z][a-z0-9+.-]*:\/\/)([^/\s@]+)@/gi, "$1[redacted]@")
-    .replace(/([?&](?:access_token|api_key|key|secret|token)=)[^&\s]+/gi, "$1[redacted]")
-    .replace(/Bearer\s+[^"'\s]+/gi, "Bearer [redacted]")
-    .replace(/sk-[A-Za-z0-9_-]+/g, "sk-[redacted]");
-}
-
-function safeUpstreamError(text: string) {
-  try {
-    const parsed = JSON.parse(text);
-    const error = parsed?.error || {};
-    return {
-      code: safeDiagnosticLabel(error.code),
-      type: safeDiagnosticLabel(error.type),
-      param: safeDiagnosticLabel(error.param),
-    };
-  } catch {
-    return { code: null, type: null, param: null };
-  }
-}
-
-function reasonFrom(result: Omit<ImageDoctorProbeResult, "diagnosticReason">): string | null {
-  const diagnostics = result.response.diagnostics;
-  if (!result.error && result.ok) return null;
-  if (result.error?.code) return result.error.code;
-  if (!diagnostics) return "probe_failed";
-  if (diagnostics.streamStats.bytesRead > 0 && result.response.eventCount === 0) return "stream_parse_failed";
-  if (diagnostics.imageCallFailed) return "image_tool_failed";
-  if (diagnostics.imageCallCompleted && diagnostics.imageResultCount === 0) return "image_tool_completed_without_result";
-  if (!diagnostics.imageCallSeen && result.response.webSearchCalls > 0) return "web_search_only_response";
-  if (!diagnostics.imageCallSeen && diagnostics.messageOutputSeen) return "image_tool_not_called";
-  if (result.expectation === "text" && result.response.textOutputChars === 0) return "text_output_missing";
-  if (result.expectation === "image" && result.response.imageResultCount === 0) return "image_output_missing";
-  return "probe_failed";
-}
-
-async function runSingleProbe(provider: string, options: ImageDoctorProbeOptions, spec: ProbeSpec): Promise<ImageDoctorProbeResult> {
-  const start = Date.now();
-  let httpStatus: number | null = null;
-  let contentType: string | null = null;
-  let upstreamRequestId: string | null = null;
-  try {
-    const endpoint = await endpointFor(provider, options);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), options.timeoutMs || defaultConfig.oauth.generationTimeoutMs);
-    try {
-      const res = await fetch(endpoint.url, {
-        method: "POST",
-        headers: endpoint.headers,
-        signal: controller.signal,
-        body: JSON.stringify(spec.payload),
-      });
-      httpStatus = res.status;
-      contentType = res.headers.get("content-type");
-      upstreamRequestId = res.headers.get("x-request-id") || res.headers.get("openai-request-id");
-      if (!res.ok) {
-        const body = await res.text();
-        const upstream = safeUpstreamError(body);
-        const partial = {
-          id: spec.id,
-          ok: false,
-          expectation: spec.expectation,
-          request: {
-            stream: spec.stream,
-            toolTypes: spec.toolTypes,
-            toolChoiceKind: spec.toolChoiceKind,
-            promptId: spec.promptId,
-            promptChars: spec.promptChars,
-          },
-          response: {
-            httpStatus,
-            contentType,
-            upstreamRequestId,
-            durationMs: Date.now() - start,
-            eventCount: 0,
-            eventTypes: {},
-            webSearchCalls: 0,
-            textOutputChars: 0,
-            imageResultCount: 0,
-            firstImageChars: 0,
-            diagnostics: null,
-          },
-          error: {
-            ...upstream,
-            message: "Upstream returned a non-2xx response",
-            upstreamBodyChars: body.length,
-          },
-        };
-        return { ...partial, diagnosticReason: reasonFrom(partial) };
-      }
-      const parsed = contentType?.includes("text/event-stream")
-        ? await parseStream(res, { scope: "doctor-image-probe", maxImages: 1 })
-        : await parseJson(res, 1);
-      const ok = spec.expectation === "image"
-        ? Boolean(parsed.images[0]?.b64)
-        : Boolean(parsed.text && parsed.text.trim());
-      const partial = {
-        id: spec.id,
-        ok,
-        expectation: spec.expectation,
-        request: {
-          stream: spec.stream,
-          toolTypes: spec.toolTypes,
-          toolChoiceKind: spec.toolChoiceKind,
-          promptId: spec.promptId,
-          promptChars: spec.promptChars,
-        },
-        response: {
-          httpStatus,
-          contentType,
-          upstreamRequestId,
-          durationMs: Date.now() - start,
-          eventCount: parsed.eventCount,
-          eventTypes: parsed.eventTypes,
-          webSearchCalls: parsed.webSearchCalls,
-          textOutputChars: parsed.text?.length || 0,
-          imageResultCount: parsed.images.length,
-          firstImageChars: parsed.images[0]?.b64.length || 0,
-          diagnostics: parsed.diagnostics,
-        },
-        error: null,
-      };
-      return { ...partial, diagnosticReason: reasonFrom(partial) };
-    } finally {
-      clearTimeout(timer);
-    }
-  } catch (e) {
-    const err = errInfo(e);
-    const partial = {
-      id: spec.id,
-      ok: false,
-      expectation: spec.expectation,
-      request: {
-        stream: spec.stream,
-        toolTypes: spec.toolTypes,
-        toolChoiceKind: spec.toolChoiceKind,
-        promptId: spec.promptId,
-        promptChars: spec.promptChars,
-      },
-      response: {
-        httpStatus,
-        contentType,
-        upstreamRequestId,
-        durationMs: Date.now() - start,
-        eventCount: Number((err.raw as { eventCount?: unknown })?.eventCount) || 0,
-        eventTypes: {},
-        webSearchCalls: 0,
-        textOutputChars: 0,
-        imageResultCount: 0,
-        firstImageChars: 0,
-        diagnostics: null,
-      },
-      error: {
-        code: safeDiagnosticLabel(err.code),
-        type: null,
-        param: null,
-        message: err.name === "AbortError" ? "Probe timed out" : sanitizeProbeErrorMessage(err.message),
-      },
-    };
-    return { ...partial, diagnosticReason: reasonFrom(partial) };
-  }
-}
-
-export async function runImageDoctorProbe(options: ImageDoctorProbeOptions = {}) {
-  const provider = options.provider || "oauth";
-  const model = options.model || defaultConfig.imageModels?.default || "gpt-5.4-mini";
-  const size = options.size || "1024x1024";
-  const quality = options.quality || "low";
-  const moderation = options.moderation || "low";
-  const prompt = options.prompt || BUILTIN_CAT_PROMPT;
-  const specs = createProbeSpecs({
-    model,
-    size,
-    quality,
-    moderation,
-    prompt,
-    matrix: options.matrix === true,
-  });
-  const probes: ImageDoctorProbeResult[] = [];
-  for (const spec of specs) probes.push(await runSingleProbe(provider, options, spec));
-  return {
-    provider,
-    endpointKind: provider === "api" ? "api" : "oauth",
-    model,
-    size,
-    quality,
-    moderation,
-    promptId: options.prompt ? "custom" : BUILTIN_PROMPT_ID,
-    promptChars: prompt.length,
-    matrix: options.matrix === true,
-    probes,
-    summary: {
-      ok: probes.every((probe) => probe.ok),
-      passed: probes.filter((probe) => probe.ok).length,
-      failed: probes.filter((probe) => !probe.ok).length,
-    },
-  };
-}