ima2-gen 1.1.13 → 1.1.14

package/lib/responsesDoctor.ts

@@ -0,0 +1,456 @@
+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,
+    },
+  };
+}

package/lib/responsesErrors.js

@@ -0,0 +1,57 @@
+const RESPONSES_ERROR_MARKER = "ima2ResponsesError";
+export const RESPONSE_DIAGNOSTIC_CODES = new Set([
+    "STREAM_PARSE_FAILED",
+    "IMAGE_TOOL_NOT_CALLED",
+    "WEB_SEARCH_ONLY_RESPONSE",
+    "IMAGE_TOOL_FAILED",
+    "IMAGE_TOOL_COMPLETED_WITHOUT_RESULT",
+    "OAUTH_IMAGE_CAPABILITY_UNAVAILABLE",
+    "RESPONSES_STREAM_ERROR",
+]);
+function diagnosticReason(code) {
+    return code === "EMPTY_RESPONSE" ? null : code.toLowerCase();
+}
+function messageForCode(code, fallback) {
+    if (code === "STREAM_PARSE_FAILED")
+        return "Responses image stream could not be parsed.";
+    if (code === "WEB_SEARCH_ONLY_RESPONSE")
+        return "Responses called web search but not the image tool.";
+    if (code === "IMAGE_TOOL_NOT_CALLED")
+        return "Responses completed without calling the image tool.";
+    if (code === "IMAGE_TOOL_FAILED")
+        return "Responses image tool call failed.";
+    if (code === "IMAGE_TOOL_COMPLETED_WITHOUT_RESULT")
+        return "Responses image tool completed without image data.";
+    return fallback;
+}
+export function classifyNoImageResponse(result) {
+    const diagnostics = result.diagnostics;
+    const bytesRead = Number(diagnostics.streamStats.bytesRead);
+    if (Number.isFinite(bytesRead) && bytesRead > 0 && result.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.webSearchCalls > 0 || diagnostics.webSearchCallSeen))
+        return "WEB_SEARCH_ONLY_RESPONSE";
+    if (!diagnostics.imageCallSeen && diagnostics.messageOutputSeen)
+        return "IMAGE_TOOL_NOT_CALLED";
+    return "EMPTY_RESPONSE";
+}
+export function emptyResponseError(message, result, meta) {
+    const code = classifyNoImageResponse(result);
+    const err = new Error(messageForCode(code, message));
+    err.status = 422;
+    err.code = code;
+    err.eventCount = result.eventCount;
+    err.eventTypes = result.eventTypes;
+    err.webSearchCalls = result.webSearchCalls;
+    err.responseDiagnostics = result.diagnostics;
+    Object.assign(err, meta);
+    const reason = diagnosticReason(code);
+    if (reason)
+        err.diagnosticReason = reason;
+    Object.defineProperty(err, RESPONSES_ERROR_MARKER, { value: true });
+    return err;
+}

package/lib/responsesErrors.ts

@@ -0,0 +1,83 @@
+import type { ParsedResponsesResult } from "./responsesParse.js";
+
+const RESPONSES_ERROR_MARKER = "ima2ResponsesError";
+
+export const RESPONSE_DIAGNOSTIC_CODES = new Set([
+  "STREAM_PARSE_FAILED",
+  "IMAGE_TOOL_NOT_CALLED",
+  "WEB_SEARCH_ONLY_RESPONSE",
+  "IMAGE_TOOL_FAILED",
+  "IMAGE_TOOL_COMPLETED_WITHOUT_RESULT",
+  "OAUTH_IMAGE_CAPABILITY_UNAVAILABLE",
+  "RESPONSES_STREAM_ERROR",
+]);
+
+export interface EmptyResponseMeta {
+  provider?: string;
+  model?: string;
+  toolTypes?: string[];
+  toolChoiceKind?: string;
+  quality?: string;
+  size?: string;
+  moderation?: string;
+  webSearchEnabled?: boolean;
+  refsCount?: number;
+  inputImageCount?: number;
+  promptChars?: number;
+  retryKind?: string;
+  initialEventCount?: number;
+  initialEventTypes?: Record<string, number>;
+  referencesDroppedOnRetry?: boolean;
+  developerPromptDroppedOnRetry?: boolean;
+  webSearchDroppedOnRetry?: boolean;
+  fallbackEventCount?: number;
+  fallbackEventTypes?: Record<string, number>;
+  fallbackImageCallSeen?: boolean;
+  fallbackImageResultCount?: number;
+}
+
+interface ResponsesError extends Error {
+  status: number;
+  code: string;
+  [key: string]: unknown;
+}
+
+function diagnosticReason(code: string): string | null {
+  return code === "EMPTY_RESPONSE" ? null : code.toLowerCase();
+}
+
+function messageForCode(code: string, fallback: string) {
+  if (code === "STREAM_PARSE_FAILED") return "Responses image stream could not be parsed.";
+  if (code === "WEB_SEARCH_ONLY_RESPONSE") return "Responses called web search but not the image tool.";
+  if (code === "IMAGE_TOOL_NOT_CALLED") return "Responses completed without calling the image tool.";
+  if (code === "IMAGE_TOOL_FAILED") return "Responses image tool call failed.";
+  if (code === "IMAGE_TOOL_COMPLETED_WITHOUT_RESULT") return "Responses image tool completed without image data.";
+  return fallback;
+}
+
+export function classifyNoImageResponse(result: ParsedResponsesResult): string {
+  const diagnostics = result.diagnostics;
+  const bytesRead = Number(diagnostics.streamStats.bytesRead);
+  if (Number.isFinite(bytesRead) && bytesRead > 0 && result.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.webSearchCalls > 0 || diagnostics.webSearchCallSeen)) return "WEB_SEARCH_ONLY_RESPONSE";
+  if (!diagnostics.imageCallSeen && diagnostics.messageOutputSeen) return "IMAGE_TOOL_NOT_CALLED";
+  return "EMPTY_RESPONSE";
+}
+
+export function emptyResponseError(message: string, result: ParsedResponsesResult, meta: EmptyResponseMeta): ResponsesError {
+  const code = classifyNoImageResponse(result);
+  const err = new Error(messageForCode(code, message)) as ResponsesError;
+  err.status = 422;
+  err.code = code;
+  err.eventCount = result.eventCount;
+  err.eventTypes = result.eventTypes;
+  err.webSearchCalls = result.webSearchCalls;
+  err.responseDiagnostics = result.diagnostics;
+  Object.assign(err, meta);
+  const reason = diagnosticReason(code);
+  if (reason) err.diagnosticReason = reason;
+  Object.defineProperty(err, RESPONSES_ERROR_MARKER, { value: true });
+  return err;
+}

package/lib/responsesFallback.js

@@ -0,0 +1,72 @@
+import { logEvent } from "./logger.js";
+import { imageToolChoice, tools } from "./responsesTools.js";
+import { emptyResponseError } from "./responsesErrors.js";
+import { buildUserTextPrompt } from "./oauthProxy.js";
+export async function retryPromptOnlyJsonImage({ postResponses, ctx, provider, prompt, mode, model, quality, size, moderation, requestId, signal, initial, referencesDroppedOnRetry, webSearchDroppedOnRetry, reasoningEffort, }) {
+    if (provider === "api")
+        return null;
+    const retryKind = "prompt_only_json_image_tool";
+    const retryMeta = {
+        retryKind,
+        initialEventCount: initial.eventCount,
+        initialEventTypes: initial.eventTypes,
+        referencesDroppedOnRetry,
+        developerPromptDroppedOnRetry: true,
+        webSearchDroppedOnRetry,
+    };
+    logEvent("oauth", "retry_json", { requestId, ...retryMeta });
+    let retry;
+    try {
+        retry = await postResponses({
+            ctx,
+            provider,
+            scope: "oauth-fallback",
+            requestId,
+            maxImages: 1,
+            signal,
+            payload: {
+                model,
+                input: [{ role: "user", content: buildUserTextPrompt(prompt, mode, { webSearchEnabled: false }) }],
+                tools: tools(false, { quality, size, moderation }),
+                tool_choice: imageToolChoice(true),
+                reasoning: { effort: reasoningEffort || "low" },
+                stream: false,
+            },
+        });
+    }
+    catch (e) {
+        if (e && typeof e === "object")
+            Object.assign(e, retryMeta);
+        throw e;
+    }
+    const image = retry.images[0];
+    if (image?.b64) {
+        logEvent("oauth", "retry_image", { requestId, retryKind, imageChars: image.b64.length });
+        return { b64: image.b64, usage: retry.usage, webSearchCalls: initial.webSearchCalls, revisedPrompt: image.revisedPrompt, text: retry.text, ...retryMeta };
+    }
+    logEvent("oauth", "retry_no_image", {
+        requestId,
+        retryKind,
+        fallbackEventCount: retry.eventCount,
+        fallbackImageCallSeen: retry.diagnostics.imageCallSeen,
+        fallbackImageResultCount: retry.diagnostics.imageResultCount,
+    });
+    throw emptyResponseError("No image data received from Responses API fallback", retry, {
+        provider,
+        model,
+        quality,
+        size,
+        moderation,
+        webSearchEnabled: false,
+        refsCount: 0,
+        inputImageCount: 0,
+        promptChars: typeof prompt === "string" ? prompt.length : 0,
+        toolTypes: ["image_generation"],
+        toolChoiceKind: "image_generation",
+        ...retryMeta,
+        fallbackEventCount: retry.eventCount,
+        fallbackEventTypes: retry.eventTypes,
+        fallbackImageCallSeen: retry.diagnostics.imageCallSeen,
+        fallbackImageResultCount: retry.diagnostics.imageResultCount,
+    });
+}