@omnicross/subscriptions 0.1.9 → 0.2.0

package/dist/index.js

@@ -1663,6 +1663,876 @@ function stripAuthHeaders(headers) {
   delete headers["x-goog-api-key"];
   delete headers["X-Goog-Api-Key"];
 }
+
+// src/image-generation/CodexSubscriptionImageProvider.ts
+import { createHash } from "crypto";
+import {
+  ImageGenerationError as ImageGenerationError4,
+  normalizeImageGenerationError,
+  resolveImageCapabilities,
+  serializeImageGenerationError
+} from "@omnicross/core/image-generation";
+import { fetchUpstream } from "@omnicross/core/pipeline/upstreamFetch";
+
+// src/image-generation/capabilityEvidence.ts
+var CODEX_IMAGE_ADAPTER_VALUES = {
+  available: true,
+  models: ["gpt-image-2"],
+  generate: true,
+  edit: true,
+  maskEdit: false,
+  maxInputImages: 1,
+  maxOutputImages: 1,
+  streaming: false,
+  maxPartialImages: 0,
+  transparentBackground: false,
+  flexibleSizes: true,
+  outputFormats: ["png", "jpeg", "webp"],
+  qualityLevels: ["auto", "low", "medium", "high"],
+  moderationModes: ["auto", "low"],
+  outputCompression: { supported: true, formats: ["jpeg", "webp"], min: 0, max: 100 },
+  responsesTool: true,
+  multiTurnEdit: false,
+  supportsFileId: false,
+  supportsImageUrl: false
+};
+function createCodexImageAdapterEvidence(now = Date.now()) {
+  return {
+    kind: "adapter",
+    source: "codex-image-adapter-declaration",
+    verifiedAt: now,
+    values: CODEX_IMAGE_ADAPTER_VALUES
+  };
+}
+var UnknownCodexImageCapabilityEvidenceSource = class {
+  async resolve(_request) {
+    return {
+      account: { kind: "account", source: "codex-image-entitlement-unknown" },
+      upstream: { kind: "upstream", source: "codex-image-protocol-unverified" }
+    };
+  }
+};
+
+// src/image-generation/privateWireErrors.ts
+import {
+  ImageGenerationError
+} from "@omnicross/core/image-generation";
+function parseRetryAfter(headers, now = Date.now()) {
+  const value = headers.get("retry-after");
+  if (!value) return void 0;
+  if (/^\d+$/.test(value)) return Math.min(604800, Number(value));
+  const at = Date.parse(value);
+  if (!Number.isFinite(at) || at <= now) return void 0;
+  return Math.min(604800, Math.ceil((at - now) / 1e3));
+}
+function privateErrorCode(body) {
+  if (!body.trim() || body.length > 1e6 || /^\s*</.test(body)) return void 0;
+  try {
+    const value = JSON.parse(body);
+    if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+    const error = value.error;
+    if (!error || typeof error !== "object" || Array.isArray(error)) return void 0;
+    const code = error.code;
+    return typeof code === "string" && code.length <= 80 ? code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function mapCandidateCodexImageFailure(response, body) {
+  const retryAfterSeconds = parseRetryAfter(response.headers);
+  const code = privateErrorCode(body);
+  const uncertain = { retryAfterSeconds, retrySafety: "unknown" };
+  if (response.status === 401 || response.status === 403) {
+    return new ImageGenerationError("upstream_auth_required", {
+      retryAfterSeconds,
+      retrySafety: "before_acceptance"
+    });
+  }
+  if (code === "subscription_usage_limit_reached" || code === "usage_limit_reached") {
+    return new ImageGenerationError("subscription_usage_limit_reached", uncertain);
+  }
+  if (code === "moderation_blocked") {
+    return new ImageGenerationError("moderation_blocked", uncertain);
+  }
+  if (response.status === 429) return new ImageGenerationError("upstream_rate_limited", uncertain);
+  if (response.status === 408 || response.status === 504) {
+    return new ImageGenerationError("image_generation_timeout", uncertain);
+  }
+  if (response.status >= 500) return new ImageGenerationError("image_generation_failed", uncertain);
+  return new ImageGenerationError("upstream_protocol_changed", uncertain);
+}
+
+// src/image-generation/privateWireRequest.ts
+import {
+  ImageGenerationError as ImageGenerationError2,
+  readImageAssetBytes
+} from "@omnicross/core/image-generation";
+import {
+  codexAcceptHeader,
+  DEFAULT_CODEX_CLI_HEADERS,
+  fillMissingHeaders
+} from "@omnicross/core/provider-proxy/identity/codexCliHeaders";
+var CANDIDATE_CODEX_IMAGE_URL = "https://chatgpt.com/backend-api/codex/responses";
+var CANDIDATE_CODEX_IMAGE_EDIT_URL = "https://chatgpt.com/backend-api/codex/images/edits";
+var CANDIDATE_CODEX_IMAGE_CARRIER_MODEL = "gpt-5.6-luna";
+var MAX_INPUT_IMAGE_BYTES = 50 * 1024 * 1024;
+function applyCandidateCodexImageHeaders(headers) {
+  fillMissingHeaders(headers, DEFAULT_CODEX_CLI_HEADERS);
+  fillMissingHeaders(headers, {
+    accept: codexAcceptHeader(true),
+    "content-type": "application/json"
+  });
+}
+function candidateCodexImageUrl(action) {
+  return action === "edit" ? CANDIDATE_CODEX_IMAGE_EDIT_URL : CANDIDATE_CODEX_IMAGE_URL;
+}
+function applyCandidateCodexImageActionHeaders(headers, action) {
+  headers.accept = action === "edit" ? "application/json" : codexAcceptHeader(true);
+}
+async function encodeInputImage(asset, signal) {
+  if (!["image/png", "image/jpeg", "image/webp"].includes(asset.mimeType)) {
+    throw new ImageGenerationError2("unsupported_image_type", { param: "image" });
+  }
+  let bytes;
+  try {
+    bytes = await readImageAssetBytes(asset, MAX_INPUT_IMAGE_BYTES, signal);
+  } catch (cause) {
+    if (signal?.aborted) throw signal.reason;
+    if (cause instanceof RangeError) {
+      throw new ImageGenerationError2("image_too_large", { param: "image", cause });
+    }
+    throw cause;
+  }
+  try {
+    const base64 = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+    return `data:${asset.mimeType};base64,${base64}`;
+  } finally {
+    bytes.fill(0);
+  }
+}
+async function buildCandidateCodexImageRequest(request, signal) {
+  if (request.action === "edit") {
+    if (request.mask || request.images.length !== 1) {
+      throw new ImageGenerationError2("unsupported_capability", { param: request.mask ? "mask" : "images" });
+    }
+    return JSON.stringify({
+      images: [{ image_url: await encodeInputImage(request.images[0], signal) }],
+      prompt: request.prompt,
+      background: request.background,
+      model: request.model,
+      quality: request.quality,
+      size: request.size.kind === "pixels" ? `${request.size.width}x${request.size.height}` : "auto"
+    });
+  }
+  const tool = {
+    type: "image_generation",
+    action: request.action,
+    model: request.model,
+    quality: request.quality,
+    background: request.background,
+    output_format: request.outputFormat
+  };
+  if (request.size.kind === "pixels") tool.size = `${request.size.width}x${request.size.height}`;
+  if (request.outputCompression !== void 0) tool.output_compression = request.outputCompression;
+  if (request.moderation !== "auto") tool.moderation = request.moderation;
+  const body = {
+    instructions: "",
+    model: CANDIDATE_CODEX_IMAGE_CARRIER_MODEL,
+    input: [{
+      type: "message",
+      role: "user",
+      content: [{ type: "input_text", text: request.prompt }]
+    }],
+    tools: [tool],
+    tool_choice: { type: "image_generation" },
+    reasoning: { effort: "medium", summary: "auto" },
+    parallel_tool_calls: true,
+    include: ["reasoning.encrypted_content"],
+    stream: true,
+    store: false
+  };
+  return JSON.stringify(body);
+}
+
+// src/image-generation/privateWireResponse.ts
+import {
+  ImageGenerationError as ImageGenerationError3,
+  InMemoryImageAsset
+} from "@omnicross/core/image-generation";
+import sharp from "sharp";
+function disposeCandidateCodexImageResponse(parsed) {
+  if (!parsed) return;
+  for (const image of parsed.images) {
+    if (image instanceof InMemoryImageAsset) image.dispose();
+  }
+}
+var MAX_CANDIDATE_RESPONSE_BYTES = 7e7;
+var MAX_DECODED_IMAGE_BYTES = 50 * 1024 * 1024;
+var MAX_DECODED_IMAGE_PIXELS = 8294400;
+var MAX_DECODED_RAW_BYTES = MAX_DECODED_IMAGE_PIXELS * 4;
+async function readCandidateCodexImageResponseBody(response) {
+  const declared = response.headers.get("content-length");
+  if (declared && (!/^\d+$/.test(declared) || Number(declared) > MAX_CANDIDATE_RESPONSE_BYTES)) {
+    return protocolChanged();
+  }
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let total = 0;
+  let body = "";
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > MAX_CANDIDATE_RESPONSE_BYTES) {
+        await reader.cancel();
+        return protocolChanged();
+      }
+      body += decoder.decode(next.value, { stream: true });
+    }
+    body += decoder.decode();
+    return body;
+  } catch (cause) {
+    return protocolChanged(cause);
+  } finally {
+    reader.releaseLock();
+  }
+}
+function selectVerifiedCandidateResponseMetadata(parsed, verified) {
+  return {
+    ...verified?.usage && parsed.usage ? { usage: parsed.usage } : {},
+    ...verified?.revisedPrompt && parsed.revisedPrompt ? { revisedPrompt: parsed.revisedPrompt } : {}
+  };
+}
+function protocolChanged(cause) {
+  throw new ImageGenerationError3("upstream_protocol_changed", { cause });
+}
+function decodeCandidateBase64ForTests(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length % 4 !== 0) {
+    return protocolChanged();
+  }
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  const decodedLength = value.length / 4 * 3 - padding;
+  if (decodedLength <= 0 || decodedLength > MAX_DECODED_IMAGE_BYTES) return protocolChanged();
+  const alphabetEnd = value.length - padding;
+  for (let index = 0; index < alphabetEnd; index += 1) {
+    const code = value.charCodeAt(index);
+    const allowed = code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
+    if (!allowed) return protocolChanged();
+  }
+  for (let index = alphabetEnd; index < value.length; index += 1) {
+    if (value.charCodeAt(index) !== 61) return protocolChanged();
+  }
+  if (padding === 1 && value.charCodeAt(value.length - 2) === 61) return protocolChanged();
+  const decoded = Buffer.from(value, "base64");
+  if (decoded.byteLength !== decodedLength || decoded.toString("base64") !== value) return protocolChanged();
+  return new Uint8Array(decoded);
+}
+function readU32Be(bytes, offset) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function readU32Le(bytes, offset) {
+  return (bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24) >>> 0;
+}
+function assertCompleteContainer(bytes, format) {
+  if (format === "jpeg") {
+    if (bytes.byteLength < 4 || bytes.at(-2) !== 255 || bytes.at(-1) !== 217) protocolChanged();
+    return;
+  }
+  if (format === "webp") {
+    if (bytes.byteLength < 20 || Buffer.from(bytes.subarray(0, 4)).toString("ascii") !== "RIFF" || Buffer.from(bytes.subarray(8, 12)).toString("ascii") !== "WEBP" || readU32Le(bytes, 4) + 8 !== bytes.byteLength) protocolChanged();
+    let offset2 = 12;
+    while (offset2 < bytes.byteLength) {
+      if (offset2 + 8 > bytes.byteLength) protocolChanged();
+      const length = readU32Le(bytes, offset2 + 4);
+      const next = offset2 + 8 + length + length % 2;
+      if (next > bytes.byteLength) protocolChanged();
+      offset2 = next;
+    }
+    if (offset2 !== bytes.byteLength) protocolChanged();
+    return;
+  }
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  if (bytes.byteLength < 20 || !signature.every((value, index) => bytes[index] === value)) {
+    protocolChanged();
+  }
+  let offset = 8;
+  let sawEnd = false;
+  while (offset < bytes.byteLength) {
+    if (offset + 12 > bytes.byteLength) protocolChanged();
+    const length = readU32Be(bytes, offset);
+    const next = offset + 12 + length;
+    if (next > bytes.byteLength) protocolChanged();
+    const type = Buffer.from(bytes.subarray(offset + 4, offset + 8)).toString("ascii");
+    if (type === "IEND") {
+      if (length !== 0 || next !== bytes.byteLength) protocolChanged();
+      sawEnd = true;
+    }
+    offset = next;
+  }
+  if (!sawEnd || offset !== bytes.byteLength) protocolChanged();
+}
+async function createAsset(value, format) {
+  const bytes = decodeCandidateBase64ForTests(value);
+  assertCompleteContainer(bytes, format);
+  const input = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  try {
+    const decoder = sharp(input, {
+      failOn: "warning",
+      limitInputPixels: MAX_DECODED_IMAGE_PIXELS,
+      sequentialRead: true
+    });
+    const metadata = await decoder.metadata();
+    if (metadata.format !== format || !Number.isSafeInteger(metadata.width) || !Number.isSafeInteger(metadata.height) || metadata.width <= 0 || metadata.height <= 0 || metadata.width * metadata.height > MAX_DECODED_IMAGE_PIXELS) return protocolChanged();
+    const decoded = await decoder.raw().toBuffer({ resolveWithObject: true });
+    if (decoded.info.width !== metadata.width || decoded.info.height !== metadata.height || !Number.isSafeInteger(decoded.info.channels) || decoded.info.channels <= 0 || decoded.info.channels > 4 || decoded.data.byteLength !== decoded.info.width * decoded.info.height * decoded.info.channels || decoded.data.byteLength > MAX_DECODED_RAW_BYTES) return protocolChanged();
+    return new InMemoryImageAsset(bytes, {
+      mimeType: `image/${format}`,
+      width: decoded.info.width,
+      height: decoded.info.height,
+      ...metadata.hasAlpha !== void 0 ? { hasAlpha: metadata.hasAlpha } : {}
+    });
+  } catch (cause) {
+    return protocolChanged(cause);
+  }
+}
+function parseUsage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const read = (key) => {
+    const item = record[key];
+    return Number.isSafeInteger(item) && item >= 0 ? item : void 0;
+  };
+  const usage = {
+    totalTokens: read("total_tokens"),
+    inputTokens: read("input_tokens"),
+    outputTokens: read("output_tokens"),
+    generatedImages: read("generated_images")
+  };
+  return Object.values(usage).some((item) => item !== void 0) ? usage : void 0;
+}
+async function parseCandidateCodexImageResponse(body, expectedCount, expectedFormat) {
+  if (!body.trim() || /^s*</.test(body)) return protocolChanged();
+  if (/^\s*(?:data|event):/u.test(body)) {
+    return parseCandidateCodexImageSse(body, expectedCount, expectedFormat);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch (cause) {
+    return protocolChanged(cause);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return protocolChanged();
+  const record = parsed;
+  if (Array.isArray(record.data)) {
+    if (record.data.length !== expectedCount) return protocolChanged();
+    const rows = record.data.map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return protocolChanged();
+      return item;
+    });
+    const images2 = await Promise.all(rows.map((item) => createAsset(item.b64_json, expectedFormat)));
+    const revised2 = rows.length === 1 && typeof rows[0]?.revised_prompt === "string" ? rows[0].revised_prompt : void 0;
+    return {
+      images: images2,
+      revisedPrompt: revised2,
+      usage: parseUsage(record.usage)
+    };
+  }
+  if (!Array.isArray(record.output)) return protocolChanged();
+  const calls = record.output.filter(
+    (item) => !!item && typeof item === "object" && !Array.isArray(item) && item.type === "image_generation_call"
+  );
+  if (calls.length !== expectedCount) return protocolChanged();
+  const images = await Promise.all(calls.map(async (call) => {
+    if (call.status !== "completed" || typeof call.result !== "string") return protocolChanged();
+    return createAsset(call.result, expectedFormat);
+  }));
+  const revised = calls.length === 1 && typeof calls[0]?.revised_prompt === "string" ? calls[0].revised_prompt : void 0;
+  return {
+    images,
+    revisedPrompt: revised,
+    usage: parseUsage(record.usage)
+  };
+}
+async function parseCandidateCodexImageSse(body, expectedCount, expectedFormat) {
+  const best = /* @__PURE__ */ new Map();
+  const completedEventResults = [];
+  let completedResponse;
+  for (const line of body.split(/\r?\n/u)) {
+    if (!line.startsWith("data:")) continue;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    let event;
+    try {
+      event = JSON.parse(payload);
+    } catch {
+      continue;
+    }
+    if (!event || typeof event !== "object" || Array.isArray(event)) continue;
+    const record = event;
+    if (typeof record.partial_image_b64 === "string") {
+      const index = record.partial_image_index === void 0 ? 0 : record.partial_image_index;
+      if (!Number.isSafeInteger(index) || index < 0 || index >= expectedCount) continue;
+      const previous = best.get(index);
+      if (!previous || record.partial_image_b64.length >= previous.length) {
+        best.set(index, record.partial_image_b64);
+      }
+    }
+    if (record.type === "response.completed") {
+      if (!record.response || typeof record.response !== "object" || Array.isArray(record.response)) {
+        return protocolChanged();
+      }
+      completedResponse = record.response;
+    }
+    if (record.type === "response.output_item.done" && record.item && typeof record.item === "object" && !Array.isArray(record.item)) {
+      const item = record.item;
+      if (item.type === "image_generation_call" && item.status === "completed" && typeof item.result === "string") {
+        completedEventResults.push(item.result);
+      }
+    }
+  }
+  const output = completedResponse?.output;
+  const calls = Array.isArray(output) ? output.filter(
+    (item) => !!item && typeof item === "object" && !Array.isArray(item) && item.type === "image_generation_call"
+  ) : [];
+  const finalResults = calls.filter(
+    (call) => call.status === "completed" && typeof call.result === "string"
+  );
+  if (best.size !== expectedCount && completedEventResults.length !== expectedCount && finalResults.length !== expectedCount) {
+    return protocolChanged();
+  }
+  const images = await Promise.all(Array.from({ length: expectedCount }, async (_unused, index) => {
+    const encoded = best.get(index) ?? completedEventResults[index] ?? finalResults[index]?.result;
+    if (!encoded) return protocolChanged();
+    return createAsset(encoded, expectedFormat);
+  }));
+  const revised = calls.length === 1 && typeof calls[0]?.revised_prompt === "string" ? calls[0].revised_prompt : void 0;
+  return {
+    images,
+    revisedPrompt: revised,
+    usage: parseUsage(completedResponse?.usage)
+  };
+}
+
+// src/image-generation/CodexSubscriptionImageProvider.ts
+var PROVIDER_ID = "codex-subscription";
+function traceAccountFingerprint(accountId) {
+  return `sha256:${createHash("sha256").update(accountId, "utf8").digest("hex")}`;
+}
+function failed(error) {
+  return { type: "failed", error: serializeImageGenerationError(error) };
+}
+var CodexSubscriptionImageProvider = class {
+  id = PROVIDER_ID;
+  #auth;
+  #evidence;
+  #executionScheduler;
+  #generationTimeoutMs;
+  #now;
+  constructor(options) {
+    this.#auth = options.authStrategy;
+    this.#evidence = options.evidenceSource ?? new UnknownCodexImageCapabilityEvidenceSource();
+    this.#executionScheduler = options.executionScheduler;
+    this.#generationTimeoutMs = options.generationTimeoutMs ?? 18e4;
+    this.#now = options.now ?? Date.now;
+  }
+  async acquire(context) {
+    if (context.signal.aborted) throw new ImageGenerationError4("request_cancelled", { cause: context.signal.reason });
+    if (this.#auth.providerId !== "codex") throw new ImageGenerationError4("upstream_auth_required");
+    let selectedAccountId;
+    const headers = {};
+    applyCandidateCodexImageHeaders(headers);
+    try {
+      await this.#auth.applyHeaders(headers, {
+        upstreamUrl: CANDIDATE_CODEX_IMAGE_URL,
+        resolvedModel: CANDIDATE_CODEX_IMAGE_CARRIER_MODEL,
+        sessionKey: context.sessionKey,
+        preferredAccountId: context.preferredAccountId,
+        preferredAccountGroup: context.preferredAccountGroup,
+        boundAccountFallbackPolicy: context.boundAccountFallbackPolicy,
+        reportSelection: (accountId) => {
+          selectedAccountId = accountId;
+        }
+      });
+    } catch (cause) {
+      throw new ImageGenerationError4("upstream_auth_required", { cause });
+    }
+    if (!selectedAccountId || !/^Bearer\s+\S+$/i.test(headers.Authorization ?? "")) {
+      headers.Authorization = "";
+      throw new ImageGenerationError4("upstream_auth_required");
+    }
+    if (context.signal.aborted) {
+      headers.Authorization = "";
+      throw new ImageGenerationError4("request_cancelled", { cause: context.signal.reason });
+    }
+    let evidence;
+    try {
+      evidence = await this.#evidence.resolve({
+        accountId: selectedAccountId,
+        signal: context.signal
+      });
+    } catch (cause) {
+      if (context.signal.aborted) {
+        headers.Authorization = "";
+        selectedAccountId = void 0;
+        throw new ImageGenerationError4("request_cancelled", { cause: context.signal.reason });
+      }
+      evidence = {
+        account: { kind: "account", source: "codex-image-evidence-source-failed" },
+        upstream: { kind: "upstream", source: "codex-image-evidence-source-failed" }
+      };
+    }
+    if (context.signal.aborted) {
+      headers.Authorization = "";
+      selectedAccountId = void 0;
+      throw new ImageGenerationError4("request_cancelled", { cause: context.signal.reason });
+    }
+    const resolvedCapabilities = resolveImageCapabilities({
+      adapter: createCodexImageAdapterEvidence(this.#now()),
+      account: evidence.account,
+      upstream: evidence.upstream
+    }, this.#now());
+    const bootstrapEligible = evidence.account.source === "codex-image-entitlement-unknown" && evidence.upstream.source === "codex-image-protocol-unverified";
+    const capabilities = resolvedCapabilities.available ? resolvedCapabilities : bootstrapEligible ? Object.freeze({
+      ...CODEX_IMAGE_ADAPTER_VALUES,
+      resolvedAt: this.#now()
+    }) : resolvedCapabilities;
+    let released = false;
+    let started = false;
+    const release = async () => {
+      if (released) return;
+      released = true;
+      headers.Authorization = "";
+      selectedAccountId = void 0;
+    };
+    return {
+      providerId: PROVIDER_ID,
+      capabilities,
+      start: (request) => {
+        if (released) throw new ImageGenerationError4("upstream_auth_required");
+        if (started) throw new ImageGenerationError4("invalid_image_request");
+        started = true;
+        if (!capabilities.available) throw new ImageGenerationError4("unsupported_capability");
+        const unsupportedAction = request.action === "generate" ? !capabilities.generate : !capabilities.edit || request.images.length === 0 || request.images.length > capabilities.maxInputImages || request.mask !== void 0 && !capabilities.maskEdit;
+        if (unsupportedAction || request.stream || request.partialImages > 0 || request.n !== 1 || !capabilities.models.includes(request.model) || !capabilities.outputFormats.includes(request.outputFormat) || !capabilities.qualityLevels.includes(request.quality) || !capabilities.moderationModes.includes(request.moderation) || request.outputCompression !== void 0 && (!Number.isInteger(request.outputCompression) || capabilities.outputCompression.supported !== true || !capabilities.outputCompression.formats.includes(request.outputFormat) || request.outputCompression < capabilities.outputCompression.min || request.outputCompression > capabilities.outputCompression.max)) {
+          throw new ImageGenerationError4("unsupported_capability");
+        }
+        return this.#createJob(
+          request,
+          context,
+          headers,
+          selectedAccountId,
+          evidence.verifiedResponseFields
+        );
+      },
+      release
+    };
+  }
+  #createJob(request, context, leaseHeaders, accountId, verifiedFields) {
+    const controller = new AbortController();
+    let cancelled = false;
+    let queueWaitMs;
+    let generationStartedAt;
+    let retryCount = 0;
+    let authRefreshCount = 0;
+    const onCallerAbort = () => controller.abort(context.signal.reason);
+    context.signal.addEventListener("abort", onCallerAbort, { once: true });
+    const cancel = async () => {
+      if (cancelled) return;
+      cancelled = true;
+      controller.abort(new Error("request_cancelled"));
+    };
+    const events = (async function* (self) {
+      let schedulerGrant;
+      let schedulerGrantReleased = false;
+      let schedulerGrantSignal;
+      let onSchedulerAbort;
+      let timeout;
+      let accepted = false;
+      try {
+        if (controller.signal.aborted) throw controller.signal.reason;
+        if (self.#executionScheduler) {
+          const queueStartedAt = self.#now();
+          try {
+            const accountKey = self.#executionScheduler.deriveAccountKey(accountId);
+            schedulerGrant = await self.#executionScheduler.acquire({
+              tenantId: context.tenantId,
+              accountKey,
+              signal: controller.signal
+            });
+          } finally {
+            queueWaitMs = Math.max(0, self.#now() - queueStartedAt);
+          }
+          schedulerGrantSignal = schedulerGrant.signal;
+          if (schedulerGrantSignal) {
+            onSchedulerAbort = () => controller.abort(schedulerGrantSignal?.reason);
+            if (schedulerGrantSignal.aborted) onSchedulerAbort();
+            else schedulerGrantSignal.addEventListener("abort", onSchedulerAbort, { once: true });
+          }
+        }
+        if (controller.signal.aborted) throw controller.signal.reason;
+        generationStartedAt = self.#now();
+        timeout = setTimeout(
+          () => controller.abort(new ImageGenerationError4("image_generation_timeout")),
+          self.#generationTimeoutMs
+        );
+        const body = await buildCandidateCodexImageRequest(request, controller.signal);
+        const upstreamUrl = candidateCodexImageUrl(request.action);
+        let response;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+          if (controller.signal.aborted) throw controller.signal.reason;
+          if (attempt > 0) retryCount += 1;
+          const requestHeaders = { ...leaseHeaders };
+          applyCandidateCodexImageActionHeaders(requestHeaders, request.action);
+          response = await fetchUpstream(
+            upstreamUrl,
+            {
+              method: "POST",
+              headers: requestHeaders,
+              body,
+              signal: controller.signal
+            },
+            {
+              providerId: "codex",
+              accountId,
+              traceAccountFingerprint: traceAccountFingerprint(accountId),
+              redactBodies: true
+            }
+          );
+          if (response.status !== 401 || attempt === 1) break;
+          const refreshed = await self.#auth.onUnauthorized(context.sessionKey);
+          if (!refreshed) break;
+          authRefreshCount += 1;
+          let refreshedAccount;
+          const refreshedHeaders = {};
+          applyCandidateCodexImageHeaders(refreshedHeaders);
+          await self.#auth.applyHeaders(refreshedHeaders, {
+            upstreamUrl,
+            resolvedModel: CANDIDATE_CODEX_IMAGE_CARRIER_MODEL,
+            sessionKey: context.sessionKey,
+            preferredAccountId: accountId,
+            boundAccountFallbackPolicy: context.boundAccountFallbackPolicy,
+            reportSelection: (id) => {
+              refreshedAccount = id;
+            }
+          });
+          if (refreshedAccount !== accountId || !/^Bearer\s+\S+$/i.test(refreshedHeaders.Authorization ?? "")) {
+            throw new ImageGenerationError4("upstream_auth_required");
+          }
+          Object.assign(leaseHeaders, refreshedHeaders);
+        }
+        if (!response) throw new ImageGenerationError4("image_generation_failed", { retrySafety: "unknown" });
+        const responseBody = await readCandidateCodexImageResponseBody(response);
+        if (!response.ok) {
+          yield failed(mapCandidateCodexImageFailure(response, responseBody));
+          return;
+        }
+        accepted = true;
+        yield { type: "accepted", acceptedAt: self.#now() };
+        const parsed = await parseCandidateCodexImageResponse(responseBody, request.n, request.outputFormat);
+        const verified = selectVerifiedCandidateResponseMetadata(parsed, verifiedFields);
+        const completed = {
+          type: "completed",
+          images: parsed.images.map((artifact, index) => ({
+            artifact,
+            ...index === 0 && verified.revisedPrompt ? { revisedPrompt: verified.revisedPrompt } : {}
+          })),
+          ...verified.usage ? { usage: verified.usage } : {}
+        };
+        yield completed;
+      } catch (cause) {
+        const normalized = controller.signal.aborted ? controller.signal.reason instanceof ImageGenerationError4 ? controller.signal.reason : new ImageGenerationError4("request_cancelled", { cause: controller.signal.reason }) : normalizeImageGenerationError(cause, "image_generation_failed", {
+          retrySafety: accepted ? "after_acceptance" : "unknown"
+        });
+        yield failed(normalized);
+      } finally {
+        if (timeout !== void 0) clearTimeout(timeout);
+        if (schedulerGrantSignal && onSchedulerAbort) {
+          schedulerGrantSignal.removeEventListener("abort", onSchedulerAbort);
+        }
+        if (schedulerGrant && !schedulerGrantReleased) {
+          schedulerGrantReleased = true;
+          await schedulerGrant.release();
+        }
+        context.signal.removeEventListener("abort", onCallerAbort);
+      }
+    })(this);
+    return {
+      events,
+      cancel,
+      observability: {
+        snapshot: () => ({
+          queueWaitMs,
+          generationStartedAt,
+          retryCount,
+          authRefreshCount
+        })
+      }
+    };
+  }
+};
+function createCodexSubscriptionImageProvider(options) {
+  return new CodexSubscriptionImageProvider(options);
+}
+
+// src/image-generation/CodexImageLiveVerifier.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  ImageGenerationError as ImageGenerationError5,
+  normalizeImageGenerationError as normalizeImageGenerationError2
+} from "@omnicross/core/image-generation";
+import { fetchUpstream as fetchUpstream2 } from "@omnicross/core/pipeline/upstreamFetch";
+var VERIFICATION_PROMPT = "A single solid black square.";
+var TESTED_REQUEST = Object.freeze({
+  action: "generate",
+  model: "gpt-image-2",
+  prompt: VERIFICATION_PROMPT,
+  n: 1,
+  quality: "low",
+  size: { kind: "auto" },
+  background: "opaque",
+  outputFormat: "png",
+  moderation: "auto",
+  stream: false,
+  partialImages: 0
+});
+function traceAccountFingerprint2(accountId) {
+  return `sha256:${createHash2("sha256").update(accountId, "utf8").digest("hex")}`;
+}
+function observation(accountId, parsed) {
+  const responseFields = {
+    ...parsed.usage ? { usage: true } : {},
+    ...parsed.revisedPrompt ? { revisedPrompt: true } : {}
+  };
+  return Object.freeze({
+    accountId,
+    model: "gpt-image-2",
+    request: Object.freeze({
+      action: "generate",
+      n: 1,
+      quality: "low",
+      size: "auto",
+      background: "opaque",
+      outputFormat: "png",
+      moderation: "auto",
+      stream: false,
+      partialImages: 0
+    }),
+    ...Object.keys(responseFields).length > 0 ? { responseFields: Object.freeze(responseFields) } : {}
+  });
+}
+var DefaultCodexImageLiveVerifier = class {
+  #auth;
+  #generationTimeoutMs;
+  constructor(options) {
+    if (!Number.isSafeInteger(options.generationTimeoutMs ?? 18e4) || (options.generationTimeoutMs ?? 18e4) <= 0) {
+      throw new TypeError("Codex image live verification timeout must be positive");
+    }
+    this.#auth = options.authStrategy;
+    this.#generationTimeoutMs = options.generationTimeoutMs ?? 18e4;
+  }
+  async verify(request) {
+    if (request.signal.aborted) {
+      throw new ImageGenerationError5("request_cancelled", { cause: request.signal.reason });
+    }
+    if (this.#auth.providerId !== "codex") {
+      throw new ImageGenerationError5("upstream_auth_required");
+    }
+    const controller = new AbortController();
+    const onCallerAbort = () => controller.abort(request.signal.reason);
+    request.signal.addEventListener("abort", onCallerAbort, { once: true });
+    const timeout = setTimeout(() => {
+      controller.abort(new ImageGenerationError5("image_generation_timeout"));
+    }, this.#generationTimeoutMs);
+    timeout.unref();
+    const headers = {};
+    applyCandidateCodexImageHeaders(headers);
+    let accountId;
+    let parsed;
+    let parsedEdit;
+    try {
+      await this.#auth.applyHeaders(headers, {
+        upstreamUrl: CANDIDATE_CODEX_IMAGE_URL,
+        resolvedModel: CANDIDATE_CODEX_IMAGE_CARRIER_MODEL,
+        sessionKey: request.sessionKey,
+        preferredAccountId: request.preferredAccountId,
+        preferredAccountGroup: request.preferredAccountGroup,
+        boundAccountFallbackPolicy: request.boundAccountFallbackPolicy,
+        reportSelection: (selectedAccountId) => {
+          accountId = selectedAccountId;
+        }
+      });
+      if (!accountId || !/^Bearer\s+\S+$/iu.test(headers.Authorization ?? "")) {
+        throw new ImageGenerationError5("upstream_auth_required");
+      }
+      if (controller.signal.aborted) throw controller.signal.reason;
+      const response = await fetchUpstream2(
+        CANDIDATE_CODEX_IMAGE_URL,
+        {
+          method: "POST",
+          headers: { ...headers },
+          body: await buildCandidateCodexImageRequest(TESTED_REQUEST, controller.signal),
+          signal: controller.signal
+        },
+        {
+          providerId: "codex",
+          accountId,
+          traceAccountFingerprint: traceAccountFingerprint2(accountId),
+          redactBodies: true
+        }
+      );
+      const responseBody = await readCandidateCodexImageResponseBody(response);
+      if (!response.ok) throw mapCandidateCodexImageFailure(response, responseBody);
+      parsed = await parseCandidateCodexImageResponse(responseBody, 1, "png");
+      if (controller.signal.aborted) throw controller.signal.reason;
+      const editRequest = {
+        ...TESTED_REQUEST,
+        action: "edit",
+        images: [parsed.images[0]]
+      };
+      const editHeaders = { ...headers };
+      applyCandidateCodexImageActionHeaders(editHeaders, "edit");
+      const editResponse = await fetchUpstream2(
+        candidateCodexImageUrl("edit"),
+        {
+          method: "POST",
+          headers: editHeaders,
+          body: await buildCandidateCodexImageRequest(editRequest, controller.signal),
+          signal: controller.signal
+        },
+        {
+          providerId: "codex",
+          accountId,
+          traceAccountFingerprint: traceAccountFingerprint2(accountId),
+          redactBodies: true
+        }
+      );
+      const editResponseBody = await readCandidateCodexImageResponseBody(editResponse);
+      if (!editResponse.ok) throw mapCandidateCodexImageFailure(editResponse, editResponseBody);
+      parsedEdit = await parseCandidateCodexImageResponse(editResponseBody, 1, "png");
+      if (controller.signal.aborted) throw controller.signal.reason;
+      return observation(accountId, parsed);
+    } catch (cause) {
+      if (controller.signal.aborted) {
+        throw controller.signal.reason instanceof ImageGenerationError5 ? controller.signal.reason : new ImageGenerationError5("request_cancelled", { cause: controller.signal.reason });
+      }
+      throw normalizeImageGenerationError2(cause, "image_generation_failed", {
+        retrySafety: "before_acceptance"
+      });
+    } finally {
+      disposeCandidateCodexImageResponse(parsed);
+      disposeCandidateCodexImageResponse(parsedEdit);
+      headers.Authorization = "";
+      accountId = void 0;
+      clearTimeout(timeout);
+      request.signal.removeEventListener("abort", onCallerAbort);
+    }
+  }
+};
+function createCodexImageLiveVerifier(options) {
+  return new DefaultCodexImageLiveVerifier(options);
+}
 export {
   DEFAULT_ACCOUNT_PRIORITY,
   LAST_USED_PERSIST_THROTTLE_MS,
@@ -1673,6 +2543,8 @@ export {
   SubscriptionProviderRegistry,
   claude_exports as claudeOAuth,
   codex_exports as codexOAuth,
+  createCodexImageLiveVerifier,
+  createCodexSubscriptionImageProvider,
   gemini_exports as geminiOAuth,
   getSubscriptionAccountService,
   getSubscriptionProviderRegistry,