@omnicross/core 0.1.9 → 0.2.0

package/dist/chunk-DEIUR2TH.js

@@ -0,0 +1,3919 @@
+// src/image-generation/capabilities.ts
+var BOOLEAN_KEYS = [
+  "available",
+  "generate",
+  "edit",
+  "maskEdit",
+  "streaming",
+  "transparentBackground",
+  "flexibleSizes",
+  "responsesTool",
+  "multiTurnEdit",
+  "supportsFileId",
+  "supportsImageUrl"
+];
+var NUMERIC_KEYS = [
+  "maxInputImages",
+  "maxOutputImages",
+  "maxPartialImages"
+];
+var OUTPUT_COMPRESSION_FORMATS = /* @__PURE__ */ new Set(["png", "jpeg", "webp"]);
+function isValidOutputCompressionCapability(value) {
+  if (!value || value.supported !== true || !Array.isArray(value.formats) || value.formats.length === 0 || value.formats.some((format) => !OUTPUT_COMPRESSION_FORMATS.has(format)) || new Set(value.formats).size !== value.formats.length || !Number.isInteger(value.min) || value.min < 0 || value.min > 100 || !Number.isInteger(value.max) || value.max < 0 || value.max > 100 || value.min > value.max) {
+    return false;
+  }
+  return true;
+}
+function intersectStrings(layers, key) {
+  const allowed = key === "outputFormats" ? /* @__PURE__ */ new Set(["png", "jpeg", "webp"]) : key === "qualityLevels" ? /* @__PURE__ */ new Set(["auto", "low", "medium", "high"]) : key === "moderationModes" ? /* @__PURE__ */ new Set(["auto", "low"]) : void 0;
+  const sets = layers.map((layer) => {
+    const value = layer.values?.[key];
+    return new Set(Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.length > 0 && item.length <= 256 && (!allowed || allowed.has(item))) : []);
+  });
+  if (sets.length === 0) return [];
+  return [...sets[0]].filter((value) => sets.slice(1).every((set) => set.has(value))).sort();
+}
+function intersectOutputCompression(layers) {
+  const values = layers.map((layer) => layer.values?.outputCompression);
+  if (!values.every(isValidOutputCompressionCapability)) {
+    return { supported: false };
+  }
+  const formats = values[0].formats.filter((format) => values.slice(1).every((value) => value.formats.includes(format))).sort();
+  const min = Math.max(...values.map((value) => value.min));
+  const max = Math.min(...values.map((value) => value.max));
+  if (formats.length === 0 || min > max) {
+    return { supported: false };
+  }
+  return { supported: true, formats, min, max };
+}
+function unavailableReason(layers, now) {
+  for (const layer of layers) {
+    if (layer.kind !== "adapter" && layer.kind !== "account" && layer.kind !== "upstream") {
+      return "missing_evidence";
+    }
+    if (!Number.isFinite(layer.verifiedAt) || !layer.values) {
+      if (layer.kind === "account") return "account_unverified";
+      if (layer.kind === "upstream") return "protocol_unverified";
+      return "missing_evidence";
+    }
+    if (layer.expiresAt != null && (!Number.isFinite(layer.expiresAt) || layer.expiresAt <= now)) {
+      return "stale_evidence";
+    }
+  }
+  const availability = layers.map((layer) => layer.values?.available);
+  if (availability.some((value) => value === true) && availability.some((value) => value === false)) {
+    return "contradictory_evidence";
+  }
+  if (availability.some((value) => value !== true)) {
+    const unavailable = layers.find((layer) => layer.values?.available === false);
+    if (unavailable?.kind === "adapter") return "adapter_unavailable";
+    if (unavailable?.kind === "account") return "account_unverified";
+    if (unavailable?.kind === "upstream") return "protocol_unverified";
+    return "missing_evidence";
+  }
+  return void 0;
+}
+function resolveImageCapabilities(evidence, now = Date.now()) {
+  const layers = [evidence.adapter, evidence.account, evidence.upstream];
+  let reason = unavailableReason(layers, now);
+  const booleans = Object.fromEntries(
+    BOOLEAN_KEYS.map((key) => [key, layers.every((layer) => layer.values?.[key] === true)])
+  );
+  const numbers = Object.fromEntries(
+    NUMERIC_KEYS.map((key) => {
+      const values = layers.map((layer) => layer.values?.[key]);
+      const valid = values.every((value) => Number.isInteger(value) && value >= 0);
+      return [key, valid ? Math.min(...values) : 0];
+    })
+  );
+  const models = intersectStrings(layers, "models");
+  const outputFormats = intersectStrings(layers, "outputFormats");
+  const qualityLevels = intersectStrings(layers, "qualityLevels");
+  const moderationModes = intersectStrings(layers, "moderationModes");
+  const outputCompression = intersectOutputCompression(layers);
+  if (!reason && models.length === 0) reason = "no_common_models";
+  if (!reason && outputFormats.length === 0) reason = "no_common_output_formats";
+  if (!reason && qualityLevels.length === 0) reason = "no_common_quality_levels";
+  if (!reason && moderationModes.length === 0) reason = "no_common_moderation_modes";
+  const verifiedAt = layers.map((layer) => layer.verifiedAt).filter((value) => typeof value === "number" && Number.isFinite(value));
+  return {
+    ...booleans,
+    ...numbers,
+    available: !reason && booleans.available && models.length > 0 && outputFormats.length > 0 && qualityLevels.length > 0 && moderationModes.length > 0,
+    models,
+    outputFormats,
+    qualityLevels,
+    moderationModes,
+    outputCompression,
+    reason,
+    resolvedAt: now,
+    oldestEvidenceAt: verifiedAt.length === layers.length ? Math.min(...verifiedAt) : void 0
+  };
+}
+
+// src/image-generation/errors.ts
+import {
+  IMAGE_GENERATION_ERROR_CODES
+} from "@omnicross/contracts/image-generation-types";
+var DEFAULT_MESSAGES = {
+  invalid_image_request: "The image request is invalid.",
+  unsupported_model: "The requested image model is not supported.",
+  unsupported_capability: "The requested image capability is not available.",
+  invalid_api_key: "The API key is invalid.",
+  upstream_auth_required: "The upstream image provider requires authentication.",
+  image_reference_not_found: "The image reference was not found.",
+  image_reference_expired: "The image reference has expired.",
+  image_too_large: "The image exceeds the configured size limit.",
+  unsupported_image_type: "The image type is not supported.",
+  moderation_blocked: "The image request was blocked by moderation.",
+  upstream_rate_limited: "The upstream image provider is rate limited.",
+  subscription_usage_limit_reached: "The subscription image usage limit has been reached.",
+  image_queue_full: "The image execution queue is full.",
+  image_queue_timeout: "The image execution queue timed out.",
+  request_cancelled: "The image request was cancelled.",
+  upstream_protocol_changed: "The upstream image protocol could not be recognized.",
+  image_generation_failed: "The upstream image generation failed.",
+  image_generation_timeout: "The upstream image generation timed out."
+};
+var DEFAULT_HTTP_STATUS = {
+  invalid_image_request: 400,
+  unsupported_model: 400,
+  unsupported_capability: 422,
+  invalid_api_key: 401,
+  upstream_auth_required: 503,
+  image_reference_not_found: 404,
+  image_reference_expired: 410,
+  image_too_large: 413,
+  unsupported_image_type: 415,
+  moderation_blocked: 422,
+  upstream_rate_limited: 429,
+  subscription_usage_limit_reached: 429,
+  image_queue_full: 429,
+  image_queue_timeout: 504,
+  request_cancelled: 499,
+  upstream_protocol_changed: 502,
+  image_generation_failed: 502,
+  image_generation_timeout: 504
+};
+function safeParam(value) {
+  return typeof value === "string" && /^[a-z][a-z0-9_.-]{0,63}$/i.test(value) ? value : void 0;
+}
+function safeModerationDetails(value) {
+  if (!value) return void 0;
+  const stage = value.stage === "input" || value.stage === "output" ? value.stage : void 0;
+  const categories = value.categories?.filter((item) => /^[a-z][a-z0-9_.-]{0,63}$/i.test(item)).slice(0, 16);
+  return stage || categories?.length ? { stage, categories: categories?.length ? categories : void 0 } : void 0;
+}
+var ImageGenerationError = class extends Error {
+  code;
+  param;
+  httpStatus;
+  retryAfterSeconds;
+  retrySafety;
+  moderationDetails;
+  constructor(code, options = {}) {
+    super(DEFAULT_MESSAGES[code]);
+    this.name = "ImageGenerationError";
+    this.code = code;
+    this.param = safeParam(options.param);
+    this.httpStatus = Number.isInteger(options.httpStatus) ? Math.min(599, Math.max(400, options.httpStatus)) : DEFAULT_HTTP_STATUS[code];
+    this.retryAfterSeconds = typeof options.retryAfterSeconds === "number" && Number.isFinite(options.retryAfterSeconds) && options.retryAfterSeconds >= 0 ? Math.min(604800, Math.floor(options.retryAfterSeconds)) : void 0;
+    this.retrySafety = options.retrySafety;
+    this.moderationDetails = safeModerationDetails(options.moderationDetails);
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        configurable: true,
+        enumerable: false,
+        writable: false
+      });
+    }
+  }
+  toJSON() {
+    return serializeImageGenerationError(this);
+  }
+};
+function isImageGenerationError(error) {
+  return error instanceof ImageGenerationError;
+}
+function serializeImageGenerationError(error) {
+  return {
+    type: error.code === "moderation_blocked" ? "image_generation_user_error" : "image_generation_error",
+    code: error.code,
+    message: DEFAULT_MESSAGES[error.code],
+    httpStatus: error.httpStatus,
+    ...error.param !== void 0 ? { param: error.param } : {},
+    ...error.retryAfterSeconds !== void 0 ? { retryAfterSeconds: error.retryAfterSeconds } : {},
+    ...error.retrySafety !== void 0 ? { retrySafety: error.retrySafety } : {},
+    ...error.moderationDetails !== void 0 ? { moderationDetails: error.moderationDetails } : {}
+  };
+}
+function normalizeImageGenerationError(error, fallbackCode = "image_generation_failed", options = {}) {
+  if (isImageGenerationError(error)) return error;
+  return new ImageGenerationError(fallbackCode, { ...options, cause: error });
+}
+function imageGenerationErrorFromPublic(value) {
+  if (!value || typeof value !== "object") return new ImageGenerationError("image_generation_failed");
+  const record2 = value;
+  const code = IMAGE_GENERATION_ERROR_CODES.includes(record2.code) ? record2.code : "image_generation_failed";
+  return new ImageGenerationError(code, {
+    param: safeParam(record2.param),
+    httpStatus: typeof record2.httpStatus === "number" ? record2.httpStatus : void 0,
+    retryAfterSeconds: typeof record2.retryAfterSeconds === "number" ? record2.retryAfterSeconds : void 0,
+    retrySafety: record2.retrySafety === "before_acceptance" || record2.retrySafety === "after_acceptance" || record2.retrySafety === "unknown" ? record2.retrySafety : void 0,
+    moderationDetails: record2.moderationDetails && typeof record2.moderationDetails === "object" ? record2.moderationDetails : void 0
+  });
+}
+
+// src/image-generation/ports.ts
+import { randomUUID } from "crypto";
+var InMemoryImageAsset = class {
+  artifactId;
+  mimeType;
+  byteLength;
+  width;
+  height;
+  hasAlpha;
+  sha256;
+  independentlyDecodable = true;
+  #bytes;
+  constructor(bytes, metadata) {
+    if (bytes.byteLength === 0) throw new TypeError("Image asset bytes must not be empty.");
+    this.#bytes = bytes.slice();
+    this.artifactId = metadata.artifactId ?? randomUUID();
+    this.mimeType = metadata.mimeType;
+    this.byteLength = bytes.byteLength;
+    this.width = metadata.width;
+    this.height = metadata.height;
+    this.hasAlpha = metadata.hasAlpha;
+    this.sha256 = metadata.sha256;
+  }
+  async open(options = {}) {
+    if (options.signal?.aborted) throw options.signal.reason;
+    const bytes = this.#bytes.slice();
+    return new ReadableStream({
+      start(controller) {
+        if (options.signal?.aborted) {
+          controller.error(options.signal.reason);
+          return;
+        }
+        controller.enqueue(bytes);
+        controller.close();
+      }
+    });
+  }
+  /** Best-effort zeroization for short-lived verified/probe artifacts. */
+  dispose() {
+    this.#bytes.fill(0);
+  }
+};
+async function readImageAssetBytes(asset, maxBytes, signal) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0 || asset.byteLength > maxBytes) {
+    throw new RangeError("Image asset exceeds the bounded read limit.");
+  }
+  if (signal?.aborted) throw signal.reason;
+  const reader = (await asset.open({ signal })).getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      if (signal?.aborted) throw signal.reason;
+      const next = await reader.read();
+      if (next.done) break;
+      total += next.value.byteLength;
+      if (total > maxBytes || total > asset.byteLength) {
+        await reader.cancel();
+        throw new RangeError("Image asset stream exceeded its declared bound.");
+      }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  if (total !== asset.byteLength) throw new RangeError("Image asset stream length did not match metadata.");
+  const output = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+var InMemoryImageReferenceStore = class {
+  #entries = /* @__PURE__ */ new Map();
+  #now;
+  constructor(now = Date.now) {
+    this.#now = now;
+  }
+  async save(input) {
+    if (!input.artifact && !input.providerReference) {
+      throw new TypeError("A retained image reference requires content or an opaque provider reference.");
+    }
+    if (!Number.isSafeInteger(input.ttlMs) || input.ttlMs <= 0) {
+      throw new RangeError("Image reference TTL must be a positive integer.");
+    }
+    const now = this.#now();
+    const metadata = {
+      ...input.metadata,
+      referenceId: randomUUID(),
+      createdAt: now,
+      expiresAt: now + input.ttlMs
+    };
+    this.#entries.set(metadata.referenceId, {
+      tenantId: input.tenantId,
+      metadata,
+      value: { artifact: input.artifact, providerReference: input.providerReference },
+      activeLeases: 0,
+      deleted: false
+    });
+    return metadata;
+  }
+  async resolve(tenantId, referenceId) {
+    const entry = this.#entries.get(referenceId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) return { status: "not_found" };
+    if (entry.metadata.expiresAt <= this.#now()) return { status: "expired" };
+    entry.activeLeases += 1;
+    let released = false;
+    return {
+      status: "found",
+      lease: {
+        metadata: entry.metadata,
+        value: entry.value,
+        async release() {
+          if (released) return;
+          released = true;
+          entry.activeLeases = Math.max(0, entry.activeLeases - 1);
+        }
+      }
+    };
+  }
+  async delete(tenantId, referenceId) {
+    const entry = this.#entries.get(referenceId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) return false;
+    entry.deleted = true;
+    if (entry.activeLeases === 0) this.#entries.delete(referenceId);
+    return true;
+  }
+  async cleanup(now = this.#now()) {
+    let removed = 0;
+    for (const [referenceId, entry] of this.#entries) {
+      if ((entry.deleted || entry.metadata.expiresAt <= now) && entry.activeLeases === 0) {
+        this.#entries.delete(referenceId);
+        removed += 1;
+      }
+    }
+    return removed;
+  }
+};
+async function emitImageTelemetry(sink, record2) {
+  try {
+    await sink?.record(record2);
+  } catch {
+  }
+}
+
+// src/image-generation/ImageOrchestrator.ts
+function safeJobObservability(job) {
+  try {
+    const value = job?.observability?.snapshot();
+    if (!value) return void 0;
+    const finite = (input) => typeof input === "number" && Number.isFinite(input) && input >= 0 ? Math.min(Number.MAX_SAFE_INTEGER, input) : void 0;
+    return {
+      queueWaitMs: finite(value.queueWaitMs),
+      generationStartedAt: finite(value.generationStartedAt),
+      retryCount: finite(value.retryCount),
+      authRefreshCount: finite(value.authRefreshCount)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function unsupported(param) {
+  throw new ImageGenerationError("unsupported_capability", { param });
+}
+function assertRequestSupported(request2, capabilities) {
+  if (typeof request2.prompt !== "string" || !request2.prompt.trim() || request2.prompt.length > 32e3) {
+    throw new ImageGenerationError("invalid_image_request", { param: "prompt" });
+  }
+  if (!capabilities.available) unsupported();
+  if (!capabilities.models.includes(request2.model)) {
+    throw new ImageGenerationError("unsupported_model", { param: "model" });
+  }
+  if (!Number.isInteger(request2.n) || request2.n <= 0) {
+    throw new ImageGenerationError("invalid_image_request", { param: "n" });
+  }
+  if (request2.n > capabilities.maxOutputImages) unsupported("n");
+  if (!capabilities.outputFormats.includes(request2.outputFormat)) unsupported("output_format");
+  if (!Array.isArray(capabilities.qualityLevels) || !capabilities.qualityLevels.includes(request2.quality)) {
+    unsupported("quality");
+  }
+  if (!Array.isArray(capabilities.moderationModes) || !capabilities.moderationModes.includes(request2.moderation)) {
+    unsupported("moderation");
+  }
+  if (request2.outputCompression !== void 0 && (!Number.isInteger(request2.outputCompression) || request2.outputCompression < 0 || request2.outputCompression > 100)) {
+    throw new ImageGenerationError("invalid_image_request", { param: "output_compression" });
+  }
+  if (request2.outputCompression !== void 0) {
+    const compression = capabilities.outputCompression;
+    if (!compression || compression.supported !== true || !compression.formats.includes(request2.outputFormat) || request2.outputCompression < compression.min || request2.outputCompression > compression.max) {
+      unsupported("output_compression");
+    }
+  }
+  if (request2.background === "transparent" && !capabilities.transparentBackground) {
+    unsupported("background");
+  }
+  if (request2.size.kind === "pixels" && !capabilities.flexibleSizes) unsupported("size");
+  if (request2.stream && !capabilities.streaming) unsupported("stream");
+  if (!Number.isInteger(request2.partialImages) || request2.partialImages < 0) {
+    throw new ImageGenerationError("invalid_image_request", { param: "partial_images" });
+  }
+  if (request2.partialImages > 0 && !request2.stream) {
+    throw new ImageGenerationError("invalid_image_request", { param: "partial_images" });
+  }
+  if (request2.partialImages > capabilities.maxPartialImages) unsupported("partial_images");
+  if (request2.action === "generate") {
+    if (!capabilities.generate) unsupported("action");
+    return;
+  }
+  if (!capabilities.edit) unsupported("action");
+  if (request2.images.length === 0) {
+    throw new ImageGenerationError("invalid_image_request", { param: "images" });
+  }
+  if (request2.images.length > capabilities.maxInputImages) unsupported("images");
+  if (request2.mask && !capabilities.maskEdit) unsupported("mask");
+}
+function sanitizeUsage(value) {
+  if (value === void 0) return void 0;
+  const keys = [
+    "totalTokens",
+    "inputTokens",
+    "outputTokens",
+    "inputTextTokens",
+    "inputImageTokens",
+    "outputImageTokens",
+    "generatedImages"
+  ];
+  const output = {};
+  for (const key of keys) {
+    const item = value[key];
+    if (item === void 0) continue;
+    if (!Number.isSafeInteger(item) || item < 0) {
+      throw new ImageGenerationError("upstream_protocol_changed");
+    }
+    output[key] = item;
+  }
+  return Object.keys(output).length ? output : void 0;
+}
+function assertArtifactMetadata(asset) {
+  if (asset.independentlyDecodable !== true || !asset.mimeType.startsWith("image/") || !Number.isSafeInteger(asset.byteLength) || asset.byteLength <= 0 || !Number.isSafeInteger(asset.width) || asset.width <= 0 || !Number.isSafeInteger(asset.height) || asset.height <= 0 || typeof asset.open !== "function") {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+}
+function sanitizeProviderOutput(value) {
+  if (!value || typeof value !== "object") {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  assertArtifactMetadata(value.artifact);
+  if (value.providerReference !== void 0 && (typeof value.providerReference !== "string" || value.providerReference.length === 0 || value.providerReference.length > 4096)) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  if (value.revisedPrompt !== void 0 && (typeof value.revisedPrompt !== "string" || value.revisedPrompt.length > 32e3)) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  return {
+    artifact: value.artifact,
+    ...value.providerReference !== void 0 ? { providerReference: value.providerReference } : {},
+    ...value.revisedPrompt !== void 0 ? { revisedPrompt: value.revisedPrompt } : {}
+  };
+}
+var OUTPUT_MIME_TYPES = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+function assertFinalOutputMatchesRequest(output, request2) {
+  const artifact = output.artifact;
+  if (artifact.mimeType !== OUTPUT_MIME_TYPES[request2.outputFormat]) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  if (request2.size.kind === "pixels" && (artifact.width !== request2.size.width || artifact.height !== request2.size.height)) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  if (request2.background === "transparent" && artifact.hasAlpha !== true) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+}
+function cancellationError(cause) {
+  return new ImageGenerationError("request_cancelled", { cause });
+}
+var ImageOrchestrator = class {
+  #registry;
+  #referenceStore;
+  #telemetrySink;
+  #now;
+  constructor(options) {
+    this.#registry = options.registry;
+    this.#referenceStore = options.referenceStore;
+    this.#telemetrySink = options.telemetrySink;
+    this.#now = options.now ?? Date.now;
+  }
+  async getCapabilities(providerId, context) {
+    let lease;
+    try {
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      lease = await this.#registry.require(providerId).acquire(context);
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      return lease.capabilities;
+    } catch (error) {
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      throw normalizeImageGenerationError(error);
+    } finally {
+      await lease?.release();
+    }
+  }
+  async *run(request2, context, options) {
+    const startedAt = this.#now();
+    let acceptedAt;
+    let firstPartialAt;
+    let lease;
+    let job;
+    let iterator;
+    let releaseStarted = false;
+    let cancelled5 = false;
+    let cancelPromise;
+    let telemetrySent = false;
+    let terminalCode;
+    let terminalKind = "failed";
+    let finalImages = [];
+    let finalUsage;
+    let accepted = false;
+    let providerTerminal = false;
+    let completionExposed = false;
+    const retentionAttempt = {
+      references: [],
+      rollbackFailures: 0
+    };
+    const releaseOnce = async () => {
+      if (!lease || releaseStarted) return;
+      releaseStarted = true;
+      await lease.release();
+    };
+    const cancelOnce = (reason = "request_cancelled") => {
+      if (!job || cancelled5) return cancelPromise ?? Promise.resolve();
+      cancelled5 = true;
+      cancelPromise = Promise.resolve(job.cancel(reason)).catch(() => void 0);
+      return cancelPromise;
+    };
+    const cancelStartedNonterminalOnce = (reason = "request_cancelled") => {
+      if (providerTerminal) return cancelPromise ?? Promise.resolve();
+      return cancelOnce(reason);
+    };
+    const sendTelemetry = async () => {
+      if (telemetrySent) return;
+      telemetrySent = true;
+      const editInputs = request2.action === "edit" ? request2.images : [];
+      const jobObservability = safeJobObservability(job);
+      await emitImageTelemetry(this.#telemetrySink, {
+        requestId: context.requestId,
+        providerId: options.providerId,
+        model: request2.model,
+        action: request2.action,
+        quality: request2.quality,
+        background: request2.background,
+        outputFormat: request2.outputFormat,
+        streaming: request2.stream,
+        inputCount: editInputs.length,
+        inputBytes: editInputs.reduce((sum, asset) => sum + asset.byteLength, 0),
+        requestedOutputCount: request2.n,
+        outputs: finalImages.map((asset) => ({
+          mimeType: asset.mimeType,
+          byteLength: asset.byteLength,
+          width: asset.width,
+          height: asset.height,
+          hasAlpha: asset.hasAlpha
+        })),
+        startedAt,
+        acceptedAt,
+        firstPartialAt,
+        ...jobObservability?.generationStartedAt !== void 0 ? { generationStartedAt: jobObservability.generationStartedAt } : {},
+        finishedAt: this.#now(),
+        terminal: terminalKind,
+        errorCode: terminalCode,
+        usage: finalUsage,
+        usageUnavailable: finalUsage === void 0,
+        ...jobObservability?.queueWaitMs !== void 0 ? { queueWaitMs: jobObservability.queueWaitMs } : {},
+        ...jobObservability?.retryCount !== void 0 ? { retryCount: jobObservability.retryCount } : {},
+        ...jobObservability?.authRefreshCount !== void 0 ? { authRefreshCount: jobObservability.authRefreshCount } : {},
+        ...options.retention?.enabled ? { referenceSaveCount: retentionAttempt.references.length } : {},
+        ...retentionAttempt.rollbackFailures > 0 ? { retentionRollbackFailures: retentionAttempt.rollbackFailures } : {}
+      });
+    };
+    const rollbackRetainedOnce = () => this.#rollbackRetained(
+      context.tenantId,
+      retentionAttempt
+    );
+    const onAbort = () => {
+      void cancelStartedNonterminalOnce();
+    };
+    context.signal.addEventListener("abort", onAbort, { once: true });
+    try {
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      lease = await this.#registry.require(options.providerId).acquire(context);
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      assertRequestSupported(request2, lease.capabilities);
+      if (options.requireResponsesTool === true && lease.capabilities.responsesTool !== true) {
+        unsupported("tools");
+      }
+      job = await lease.start(request2);
+      if (context.signal.aborted) throw cancellationError(context.signal.reason);
+      iterator = job.events[Symbol.asyncIterator]();
+      let pendingTerminal;
+      const partialIndexes = /* @__PURE__ */ new Map();
+      const partialCounts = /* @__PURE__ */ new Map();
+      while (true) {
+        let next;
+        try {
+          const read = iterator.next();
+          if (context.signal.aborted) throw cancellationError(context.signal.reason);
+          next = await Promise.race([
+            read,
+            new Promise((_resolve, reject) => {
+              const abort = () => reject(cancellationError(context.signal.reason));
+              context.signal.addEventListener("abort", abort, { once: true });
+              void read.then(
+                () => context.signal.removeEventListener("abort", abort),
+                () => context.signal.removeEventListener("abort", abort)
+              );
+            })
+          ]);
+        } catch (error) {
+          if (context.signal.aborted) throw cancellationError(context.signal.reason);
+          throw normalizeImageGenerationError(error, "image_generation_failed", {
+            retrySafety: accepted ? "after_acceptance" : "unknown"
+          });
+        }
+        if (next.done) {
+          if (!pendingTerminal) throw new ImageGenerationError("upstream_protocol_changed");
+          if (pendingTerminal.type === "completed") {
+            const { usage: providerUsage, ...terminalWithoutUsage } = pendingTerminal;
+            const safeUsage = sanitizeUsage(providerUsage);
+            const references = await this.#retainCompleted(
+              pendingTerminal,
+              context,
+              options.retention,
+              retentionAttempt
+            );
+            const completed = {
+              ...terminalWithoutUsage,
+              ...safeUsage ? { usage: safeUsage } : {},
+              ...references.length ? { references } : {}
+            };
+            finalImages = completed.images.map((image) => image.artifact);
+            finalUsage = completed.usage;
+            terminalKind = "completed";
+            if (context.signal.aborted) {
+              await rollbackRetainedOnce();
+              throw cancellationError(context.signal.reason);
+            }
+            completionExposed = true;
+            yield completed;
+          } else {
+            const safeError = imageGenerationErrorFromPublic(pendingTerminal.error);
+            terminalCode = safeError.code;
+            terminalKind = safeError.code === "request_cancelled" ? "cancelled" : "failed";
+            await sendTelemetry();
+            yield { type: "failed", error: serializeImageGenerationError(safeError) };
+          }
+          return;
+        }
+        const event = next.value;
+        if (pendingTerminal) {
+          throw new ImageGenerationError("upstream_protocol_changed", {
+            retrySafety: accepted ? "after_acceptance" : "unknown"
+          });
+        }
+        switch (event.type) {
+          case "accepted":
+            if (accepted || !Number.isFinite(event.acceptedAt)) {
+              throw new ImageGenerationError("upstream_protocol_changed");
+            }
+            accepted = true;
+            acceptedAt = event.acceptedAt;
+            yield { type: "accepted", acceptedAt: event.acceptedAt };
+            break;
+          case "partial_image": {
+            if (!accepted) throw new ImageGenerationError("upstream_protocol_changed");
+            firstPartialAt ??= this.#now();
+            const image = sanitizeProviderOutput(event.image);
+            if (!Number.isInteger(event.outputIndex) || event.outputIndex < 0 || event.outputIndex >= request2.n || !Number.isInteger(event.partialImageIndex) || event.partialImageIndex < 0) {
+              throw new ImageGenerationError("upstream_protocol_changed");
+            }
+            const previous = partialIndexes.get(event.outputIndex);
+            if (previous != null && event.partialImageIndex <= previous) {
+              throw new ImageGenerationError("upstream_protocol_changed");
+            }
+            const nextCount = (partialCounts.get(event.outputIndex) ?? 0) + 1;
+            if (nextCount > request2.partialImages || event.partialImageIndex >= request2.partialImages) {
+              throw new ImageGenerationError("upstream_protocol_changed");
+            }
+            partialIndexes.set(event.outputIndex, event.partialImageIndex);
+            partialCounts.set(event.outputIndex, nextCount);
+            yield {
+              type: "partial_image",
+              outputIndex: event.outputIndex,
+              partialImageIndex: event.partialImageIndex,
+              image
+            };
+            break;
+          }
+          case "completed": {
+            if (!accepted || !Array.isArray(event.images) || event.images.length !== request2.n) {
+              throw new ImageGenerationError("upstream_protocol_changed", {
+                retrySafety: accepted ? "after_acceptance" : "unknown"
+              });
+            }
+            const images = event.images.map((image) => {
+              const output = sanitizeProviderOutput(image);
+              assertFinalOutputMatchesRequest(output, request2);
+              return output;
+            });
+            pendingTerminal = {
+              type: "completed",
+              images,
+              ...event.usage !== void 0 ? { usage: event.usage } : {}
+            };
+            providerTerminal = true;
+            break;
+          }
+          case "failed":
+            pendingTerminal = event;
+            providerTerminal = true;
+            break;
+          default:
+            throw new ImageGenerationError("upstream_protocol_changed");
+        }
+      }
+    } catch (error) {
+      if (completionExposed) throw error;
+      const normalized = context.signal.aborted ? cancellationError(context.signal.reason) : normalizeImageGenerationError(error, "image_generation_failed", {
+        retrySafety: acceptedAt == null ? "unknown" : "after_acceptance"
+      });
+      if (normalized.code === "request_cancelled") await rollbackRetainedOnce();
+      terminalCode = normalized.code;
+      terminalKind = normalized.code === "request_cancelled" ? "cancelled" : "failed";
+      await sendTelemetry();
+      throw normalized;
+    } finally {
+      if (completionExposed) await sendTelemetry();
+      context.signal.removeEventListener("abort", onAbort);
+      await cancelStartedNonterminalOnce();
+      try {
+        await iterator?.return?.();
+      } catch {
+      }
+      await cancelPromise;
+      await releaseOnce();
+    }
+  }
+  async #retainCompleted(event, context, retention, attempt) {
+    if (!retention?.enabled) return [];
+    if (!this.#referenceStore) {
+      throw new ImageGenerationError("image_generation_failed", { retrySafety: "after_acceptance" });
+    }
+    if (!Number.isSafeInteger(retention.ttlMs) || retention.ttlMs <= 0) {
+      throw new ImageGenerationError("invalid_image_request", { param: "reference_ttl" });
+    }
+    const references = [];
+    for (const image of event.images) {
+      const asset = image.artifact;
+      const reference = await this.#referenceStore.save({
+        tenantId: context.tenantId,
+        ttlMs: retention.ttlMs,
+        artifact: asset,
+        providerReference: image.providerReference,
+        metadata: {
+          mimeType: asset.mimeType,
+          byteLength: asset.byteLength,
+          width: asset.width,
+          height: asset.height
+        }
+      });
+      references.push(reference);
+      attempt.references.push(reference);
+      if (context.signal.aborted) {
+        await this.#rollbackRetained(context.tenantId, attempt);
+        throw cancellationError(context.signal.reason);
+      }
+    }
+    return references;
+  }
+  async #rollbackRetained(tenantId, attempt) {
+    attempt.rollbackPromise ??= (async () => {
+      const store = this.#referenceStore;
+      if (!store) return;
+      for (const reference of attempt.references) {
+        try {
+          if (!await store.delete(tenantId, reference.referenceId)) {
+            attempt.rollbackFailures += 1;
+          }
+        } catch {
+          attempt.rollbackFailures += 1;
+        }
+      }
+    })();
+    await attempt.rollbackPromise;
+  }
+};
+
+// src/image-generation/ImageProviderRegistry.ts
+var ImageProviderRegistry = class {
+  #providers = /* @__PURE__ */ new Map();
+  constructor(providers = []) {
+    for (const provider of providers) this.register(provider);
+  }
+  register(provider) {
+    const id = provider.id.trim();
+    if (!id) throw new TypeError("Image provider ID must not be empty.");
+    if (this.#providers.has(id)) throw new Error(`Duplicate image provider ID: ${id}`);
+    this.#providers.set(id, provider);
+  }
+  resolve(id) {
+    return this.#providers.get(id);
+  }
+  require(id) {
+    const provider = this.resolve(id);
+    if (!provider) throw new Error(`Image provider is not registered: ${id}`);
+    return provider;
+  }
+  list() {
+    return [...this.#providers.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, provider]) => provider);
+  }
+};
+
+// src/image-generation/openai-images/TemporaryImageAsset.ts
+import { createReadStream } from "fs";
+import {
+  mkdir,
+  mkdtemp,
+  open,
+  chmod,
+  realpath,
+  rm,
+  stat,
+  unlink
+} from "fs/promises";
+import { tmpdir } from "os";
+import { basename, dirname, join, resolve } from "path";
+import { Readable } from "stream";
+import { randomUUID as randomUUID2 } from "crypto";
+var IMAGE_REQUEST_DIRECTORY_MARKER_NAME = ".omnicross-images-owner.json";
+var IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT = '{"schema":"omnicross-images-temporary","version":1}\n';
+function cancelled(signal) {
+  throw new ImageGenerationError("request_cancelled", { cause: signal.reason });
+}
+function tooLarge() {
+  throw new ImageGenerationError("image_too_large");
+}
+function assertPositiveLimit(value) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError("Temporary file limits must be positive safe integers.");
+}
+var StagedTemporaryFile = class {
+  byteLength;
+  #path;
+  #scope;
+  #kind;
+  #disposed = false;
+  constructor(scope, path, byteLength2, kind) {
+    this.#scope = scope;
+    this.#path = path;
+    this.byteLength = byteLength2;
+    this.#kind = kind;
+  }
+  async open(signal) {
+    if (this.#disposed) throw new ImageGenerationError("request_cancelled");
+    this.#scope.assertActive();
+    if (signal?.aborted) cancelled(signal);
+    const source = createReadStream(this.#path, {
+      flags: "r",
+      mode: 384,
+      start: 0,
+      end: this.byteLength - 1,
+      autoClose: true,
+      ...signal ? { signal } : {}
+    });
+    return Readable.toWeb(source);
+  }
+  /** Internal validator seam; no path is returned or retained by the caller. */
+  async inspect(callback) {
+    if (this.#disposed) throw new ImageGenerationError("request_cancelled");
+    this.#scope.assertActive();
+    return callback(this.#path);
+  }
+  async dispose() {
+    if (this.#disposed || this.#kind !== "spool") return;
+    this.#disposed = true;
+    await this.#scope.releaseSpool(this.#path, this.byteLength);
+  }
+  toImageAsset(metadata) {
+    return new TemporaryImageAsset(this, metadata);
+  }
+};
+var TemporaryImageAsset = class {
+  artifactId;
+  mimeType;
+  byteLength;
+  width;
+  height;
+  hasAlpha;
+  sha256;
+  independentlyDecodable = true;
+  #file;
+  constructor(file, metadata) {
+    if (file.byteLength <= 0) throw new TypeError("Temporary image assets must not be empty.");
+    this.#file = file;
+    this.artifactId = randomUUID2();
+    this.mimeType = metadata.mimeType;
+    this.byteLength = file.byteLength;
+    this.width = metadata.width;
+    this.height = metadata.height;
+    this.hasAlpha = metadata.hasAlpha;
+    this.sha256 = metadata.sha256;
+  }
+  open(options = {}) {
+    return this.#file.open(options.signal);
+  }
+};
+var RequestFileWriter = class {
+  #scope;
+  #handle;
+  #path;
+  #kind;
+  #maxBytes;
+  #declaredBytes;
+  #byteLength = 0;
+  #done = false;
+  constructor(options) {
+    this.#scope = options.scope;
+    this.#handle = options.handle;
+    this.#path = options.path;
+    this.#kind = options.kind;
+    this.#maxBytes = options.maxBytes;
+    this.#declaredBytes = options.declaredBytes;
+  }
+  get byteLength() {
+    return this.#byteLength;
+  }
+  async write(chunk, signal) {
+    if (this.#done) throw new TypeError("Temporary writer is already closed.");
+    if (signal?.aborted) cancelled(signal);
+    if (!(chunk instanceof Uint8Array) || chunk.byteLength === 0) return;
+    const next = this.#byteLength + chunk.byteLength;
+    if (!Number.isSafeInteger(next) || next > this.#maxBytes || this.#declaredBytes !== void 0 && next > this.#declaredBytes) {
+      tooLarge();
+    }
+    this.#scope.reserve(this.#kind, chunk.byteLength);
+    try {
+      let offset = 0;
+      while (offset < chunk.byteLength) {
+        if (signal?.aborted) cancelled(signal);
+        const result = await this.#handle.write(chunk, offset, chunk.byteLength - offset, null);
+        if (result.bytesWritten <= 0) throw new ImageGenerationError("image_generation_failed");
+        offset += result.bytesWritten;
+      }
+      this.#byteLength = next;
+    } catch (error) {
+      this.#scope.unreserve(this.#kind, chunk.byteLength);
+      throw error;
+    }
+  }
+  async finish() {
+    if (this.#done) throw new TypeError("Temporary writer is already closed.");
+    this.#done = true;
+    this.#scope.writerFinished(this);
+    try {
+      await this.#handle.sync();
+    } finally {
+      await this.#handle.close().catch(() => void 0);
+    }
+    if (this.#byteLength === 0 || this.#declaredBytes !== void 0 && this.#byteLength !== this.#declaredBytes) {
+      throw new ImageGenerationError("invalid_image_request");
+    }
+    const info = await stat(this.#path);
+    if (!info.isFile() || info.size !== this.#byteLength) throw new ImageGenerationError("image_generation_failed");
+    return new StagedTemporaryFile(this.#scope, this.#path, this.#byteLength, this.#kind);
+  }
+  async abort() {
+    if (this.#done) return;
+    this.#done = true;
+    this.#scope.writerFinished(this);
+    await this.#handle.close().catch(() => void 0);
+  }
+};
+var ImageRequestResourceScope = class _ImageRequestResourceScope {
+  #limits;
+  #signal;
+  #safeRoot;
+  #requestDirectory;
+  #budgetLease;
+  #releaseDirectoryLease;
+  #writers = /* @__PURE__ */ new Set();
+  #leases = /* @__PURE__ */ new Set();
+  #inputBytes = 0;
+  #spoolBytes = 0;
+  #cleaned = false;
+  #cleanupPromise;
+  constructor(options) {
+    this.#limits = options.limits;
+    this.#signal = options.signal;
+    this.#safeRoot = options.safeRoot;
+    this.#requestDirectory = options.requestDirectory;
+    this.#budgetLease = options.budgetLease;
+    this.#releaseDirectoryLease = options.releaseDirectoryLease;
+  }
+  static async create(options) {
+    if (options.signal.aborted) cancelled(options.signal);
+    const tenantId = options.tenantId?.trim();
+    if (options.sharedBudget && !tenantId) {
+      throw new TypeError("A shared image temporary budget requires a trusted tenant id.");
+    }
+    const budgetLease = options.sharedBudget?.acquireScope(tenantId);
+    let createdDirectory;
+    let requestDirectory;
+    try {
+      const requestedRoot = resolve(options.tempRoot ?? tmpdir());
+      await mkdir(requestedRoot, { recursive: true, mode: 448 });
+      const safeRoot = await realpath(requestedRoot);
+      createdDirectory = await mkdtemp(join(safeRoot, "omnicross-images-"));
+      await chmod(createdDirectory, 448);
+      requestDirectory = await realpath(createdDirectory);
+      if (dirname(requestDirectory) !== safeRoot || !basename(requestDirectory).startsWith("omnicross-images-")) {
+        throw new TypeError("Temporary image request directory escaped the injected safe root.");
+      }
+      if (options.ownedDirectoryMarker) {
+        const marker = await open(
+          join(requestDirectory, IMAGE_REQUEST_DIRECTORY_MARKER_NAME),
+          "wx",
+          384
+        );
+        try {
+          await marker.writeFile(IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT, { encoding: "utf8" });
+          await marker.sync();
+        } finally {
+          await marker.close().catch(() => void 0);
+        }
+      }
+      const releaseDirectoryLease = options.onDirectoryActive?.(requestDirectory);
+      return new _ImageRequestResourceScope({
+        ...options,
+        safeRoot,
+        requestDirectory,
+        ...budgetLease ? { budgetLease } : {},
+        ...releaseDirectoryLease ? { releaseDirectoryLease } : {}
+      });
+    } catch (error) {
+      if (createdDirectory) {
+        await rm(createdDirectory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 }).catch(() => void 0);
+      }
+      budgetLease?.releaseScope();
+      throw error;
+    }
+  }
+  assertActive() {
+    if (this.#cleaned) throw new ImageGenerationError("request_cancelled");
+    if (this.#signal.aborted) cancelled(this.#signal);
+  }
+  reserve(kind, bytes) {
+    this.assertActive();
+    const current = kind === "input" ? this.#inputBytes : this.#spoolBytes;
+    const max = kind === "input" ? this.#limits.maxTotalInputBytes : this.#limits.maxSpoolBytes;
+    if (!Number.isSafeInteger(current + bytes) || current + bytes > max) tooLarge();
+    this.#budgetLease?.reserve(bytes);
+    if (kind === "input") this.#inputBytes += bytes;
+    else this.#spoolBytes += bytes;
+  }
+  unreserve(kind, bytes) {
+    const current = kind === "input" ? this.#inputBytes : this.#spoolBytes;
+    const released = Math.min(current, Math.max(0, bytes));
+    if (kind === "input") this.#inputBytes -= released;
+    else this.#spoolBytes -= released;
+    if (released > 0) this.#budgetLease?.release(released);
+  }
+  writerFinished(writer) {
+    this.#writers.delete(writer);
+  }
+  async releaseSpool(privatePath, bytes) {
+    const target = resolve(privatePath);
+    if (dirname(target) !== this.#requestDirectory || basename(target).length < 16) {
+      throw new TypeError("Refusing to remove an unverified image spool.");
+    }
+    try {
+      await unlink(target).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+    } finally {
+      this.unreserve("spool", bytes);
+    }
+  }
+  async createWriter(options) {
+    this.assertActive();
+    assertPositiveLimit(options.maxBytes);
+    if (options.declaredBytes !== void 0) {
+      if (!Number.isSafeInteger(options.declaredBytes) || options.declaredBytes <= 0) tooLarge();
+      if (options.declaredBytes > options.maxBytes) tooLarge();
+    }
+    const privatePath = join(this.#requestDirectory, randomUUID2());
+    const handle = await open(privatePath, "wx", 384);
+    const writer = new RequestFileWriter({
+      scope: this,
+      handle,
+      path: privatePath,
+      ...options
+    });
+    this.#writers.add(writer);
+    return writer;
+  }
+  async materialize(source, options = {}) {
+    const signal = options.signal ?? this.#signal;
+    const writer = await this.createWriter({
+      kind: options.kind ?? "input",
+      maxBytes: options.maxBytes ?? this.#limits.maxFileBytes,
+      ...options.declaredBytes !== void 0 ? { declaredBytes: options.declaredBytes } : {}
+    });
+    try {
+      for await (const chunk of source) await writer.write(chunk, signal);
+      return await writer.finish();
+    } catch (error) {
+      await writer.abort();
+      throw error;
+    }
+  }
+  addLease(lease) {
+    this.assertActive();
+    this.#leases.add(lease);
+  }
+  async cleanup() {
+    if (this.#cleanupPromise) return this.#cleanupPromise;
+    this.#cleaned = true;
+    this.#cleanupPromise = (async () => {
+      try {
+        await Promise.allSettled([...this.#writers].map((writer) => writer.abort()));
+        this.#writers.clear();
+        await Promise.allSettled([...this.#leases].map((lease) => lease.release()));
+        this.#leases.clear();
+        const target = resolve(this.#requestDirectory);
+        if (dirname(target) !== this.#safeRoot || !basename(target).startsWith("omnicross-images-")) {
+          throw new TypeError("Refusing to clean an unverified temporary image directory.");
+        }
+        await rm(target, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+      } finally {
+        this.unreserve("input", this.#inputBytes);
+        this.unreserve("spool", this.#spoolBytes);
+        this.#budgetLease?.releaseScope();
+        this.#releaseDirectoryLease?.();
+      }
+    })();
+    return this.#cleanupPromise;
+  }
+};
+function createImageRequestResourceScope(limits, signal, tempRoot, ownership) {
+  return ImageRequestResourceScope.create({
+    limits,
+    signal,
+    ...tempRoot ? { tempRoot } : {},
+    ...ownership ? ownership : {}
+  });
+}
+
+// src/image-generation/openai-images/imageApiErrors.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var SAFE_STATUS = {
+  invalid_image_request: 400,
+  unsupported_model: 400,
+  unsupported_capability: 422,
+  invalid_api_key: 401,
+  upstream_auth_required: 503,
+  image_reference_not_found: 404,
+  image_reference_expired: 410,
+  image_too_large: 413,
+  unsupported_image_type: 415,
+  moderation_blocked: 422,
+  upstream_rate_limited: 429,
+  subscription_usage_limit_reached: 429,
+  image_queue_full: 429,
+  image_queue_timeout: 504,
+  request_cancelled: 499,
+  upstream_protocol_changed: 502,
+  image_generation_failed: 502,
+  image_generation_timeout: 504
+};
+function safeImageRequestId(value) {
+  return typeof value === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(value) ? value : randomUUID3();
+}
+function imageApiErrorFromUnknown(error) {
+  return error instanceof ImageGenerationError ? error : normalizeImageGenerationError(error, "image_generation_failed");
+}
+function imageApiErrorFromProvider(value) {
+  return imageGenerationErrorFromPublic(value);
+}
+function serializeImageApiError(error) {
+  const domainError = imageApiErrorFromUnknown(error);
+  const safe = serializeImageGenerationError(domainError);
+  const headers = {};
+  if (safe.retryAfterSeconds !== void 0) headers["Retry-After"] = String(safe.retryAfterSeconds);
+  return {
+    status: SAFE_STATUS[safe.code],
+    headers,
+    domainError,
+    body: {
+      error: {
+        message: safe.message,
+        type: safe.type,
+        code: safe.code,
+        ...safe.param !== void 0 ? { param: safe.param } : {},
+        ...safe.retryAfterSeconds !== void 0 ? { retry_after_seconds: safe.retryAfterSeconds } : {},
+        ...safe.moderationDetails !== void 0 ? {
+          moderation_details: {
+            ...safe.moderationDetails.stage ? { stage: safe.moderationDetails.stage } : {},
+            ...safe.moderationDetails.categories?.length ? { categories: safe.moderationDetails.categories } : {}
+          }
+        } : {}
+      }
+    }
+  };
+}
+function writeImageApiError(response, error, requestId) {
+  const mapped = serializeImageApiError(error);
+  if (!response.headersSent && !response.writableEnded && !response.destroyed) {
+    response.writeHead(mapped.status, {
+      "Content-Type": "application/json; charset=utf-8",
+      "x-request-id": safeImageRequestId(requestId),
+      ...mapped.headers
+    });
+    response.end(JSON.stringify(mapped.body));
+  }
+  return mapped.domainError;
+}
+
+// src/image-generation/openai-images/imageApiResponse.ts
+function cancelled2(signal) {
+  throw new ImageGenerationError("request_cancelled", { cause: signal.reason });
+}
+async function writeWithBackpressure(response, chunk, signal) {
+  if (signal.aborted || response.destroyed || response.writableEnded) cancelled2(signal);
+  if (response.write(chunk)) return;
+  await new Promise((resolve2, reject) => {
+    const cleanup = () => {
+      response.removeListener("drain", onDrain);
+      response.removeListener("close", onClose);
+      response.removeListener("error", onError);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve2();
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new ImageGenerationError("request_cancelled"));
+    };
+    const onError = () => {
+      cleanup();
+      reject(new ImageGenerationError("request_cancelled"));
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(new ImageGenerationError("request_cancelled", { cause: signal.reason }));
+    };
+    response.once("drain", onDrain);
+    response.once("close", onClose);
+    response.once("error", onError);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function* encodeAssetBase64Chunks(asset, limit, signal) {
+  if (asset.byteLength <= 0 || asset.byteLength > limit) throw new ImageGenerationError("image_too_large");
+  const reader = (await asset.open({ signal })).getReader();
+  let carry = Buffer.alloc(0);
+  let observed = 0;
+  try {
+    while (true) {
+      if (signal.aborted) cancelled2(signal);
+      const next = await reader.read();
+      if (next.done) break;
+      observed += next.value.byteLength;
+      if (observed > limit || observed > asset.byteLength) throw new ImageGenerationError("image_too_large");
+      const source = carry.byteLength ? Buffer.concat([carry, Buffer.from(next.value)]) : Buffer.from(next.value);
+      const complete = source.byteLength - source.byteLength % 3;
+      if (complete) yield Buffer.from(source.subarray(0, complete).toString("base64"), "ascii");
+      carry = Buffer.from(source.subarray(complete));
+    }
+    if (observed !== asset.byteLength) throw new ImageGenerationError("upstream_protocol_changed");
+    if (carry.byteLength) yield Buffer.from(carry.toString("base64"), "ascii");
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+}
+function outputUsage(usage) {
+  if (!usage) return void 0;
+  return {
+    ...usage.totalTokens !== void 0 ? { total_tokens: usage.totalTokens } : {},
+    ...usage.inputTokens !== void 0 ? { input_tokens: usage.inputTokens } : {},
+    ...usage.outputTokens !== void 0 ? { output_tokens: usage.outputTokens } : {},
+    ...usage.generatedImages !== void 0 ? { generated_images: usage.generatedImages } : {},
+    ...usage.inputTextTokens !== void 0 || usage.inputImageTokens !== void 0 ? {
+      input_tokens_details: {
+        ...usage.inputTextTokens !== void 0 ? { text_tokens: usage.inputTextTokens } : {},
+        ...usage.inputImageTokens !== void 0 ? { image_tokens: usage.inputImageTokens } : {}
+      }
+    } : {},
+    ...usage.outputImageTokens !== void 0 ? { output_tokens_details: { image_tokens: usage.outputImageTokens } } : {}
+  };
+}
+async function stageOutputs(event, count, scope, limits, signal) {
+  if (event.images.length !== count) throw new ImageGenerationError("upstream_protocol_changed");
+  const total = event.images.reduce((sum, image) => sum + image.artifact.byteLength, 0);
+  if (!Number.isSafeInteger(total) || total > limits.maxTotalOutputBytes) {
+    throw new ImageGenerationError("image_too_large");
+  }
+  const outputs = [];
+  for (const image of event.images) {
+    const encodedLength = Math.ceil(image.artifact.byteLength / 3) * 4;
+    const base64 = await scope.materialize(
+      encodeAssetBase64Chunks(image.artifact, limits.maxOutputBytes, signal),
+      {
+        kind: "spool",
+        maxBytes: encodedLength,
+        declaredBytes: encodedLength,
+        signal
+      }
+    );
+    outputs.push({
+      base64,
+      ...image.revisedPrompt !== void 0 ? { revisedPrompt: image.revisedPrompt } : {}
+    });
+  }
+  return outputs;
+}
+async function terminalEvent(events, signal) {
+  let accepted = false;
+  let completed;
+  for await (const event of events) {
+    if (signal.aborted) cancelled2(signal);
+    if (event.type === "accepted") {
+      if (accepted || completed) throw new ImageGenerationError("upstream_protocol_changed");
+      accepted = true;
+    } else if (event.type === "partial_image") {
+      throw new ImageGenerationError("upstream_protocol_changed");
+    } else if (event.type === "failed") {
+      throw imageApiErrorFromProvider(event.error);
+    } else {
+      if (!accepted || completed) throw new ImageGenerationError("upstream_protocol_changed");
+      completed = event;
+    }
+  }
+  if (!completed) throw new ImageGenerationError("upstream_protocol_changed");
+  return completed;
+}
+async function writeImageApiResponse(options) {
+  const completed = await terminalEvent(options.events, options.signal);
+  const outputs = await stageOutputs(
+    completed,
+    options.requestedCount,
+    options.scope,
+    options.limits,
+    options.signal
+  );
+  const usage = outputUsage(completed.usage);
+  options.response.writeHead(200, {
+    "Content-Type": "application/json; charset=utf-8",
+    "x-request-id": safeImageRequestId(options.requestId)
+  });
+  await writeWithBackpressure(
+    options.response,
+    `{"created":${Math.floor(options.createdAt / 1e3)},"data":[`,
+    options.signal
+  );
+  for (let index = 0; index < outputs.length; index += 1) {
+    const output = outputs[index];
+    await writeWithBackpressure(options.response, `${index ? "," : ""}{"b64_json":"`, options.signal);
+    const reader = (await output.base64.open(options.signal)).getReader();
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        await writeWithBackpressure(options.response, next.value, options.signal);
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+      reader.releaseLock();
+    }
+    await writeWithBackpressure(
+      options.response,
+      `"${output.revisedPrompt !== void 0 ? `,"revised_prompt":${JSON.stringify(output.revisedPrompt)}` : ""}}`,
+      options.signal
+    );
+  }
+  await writeWithBackpressure(
+    options.response,
+    `]${usage ? `,"usage":${JSON.stringify(usage)}` : ""}}`,
+    options.signal
+  );
+  options.response.end();
+  await Promise.all(outputs.map((output) => output.base64.dispose()));
+}
+
+// src/image-generation/openai-images/imageApiSse.ts
+function cancelled3(signal) {
+  throw new ImageGenerationError("request_cancelled", { cause: signal.reason });
+}
+async function stageAsset(asset, scope, limits, signal) {
+  const encodedLength = Math.ceil(asset.byteLength / 3) * 4;
+  return scope.materialize(encodeAssetBase64Chunks(asset, limits.maxOutputBytes, signal), {
+    kind: "spool",
+    maxBytes: encodedLength,
+    declaredBytes: encodedLength,
+    signal
+  });
+}
+async function writeAssetFrame(options) {
+  const prefix = JSON.stringify({ type: options.type, ...options.beforeImage, b64_json: "__IMAGE__" });
+  const marker = '"__IMAGE__"';
+  const markerAt = prefix.indexOf(marker);
+  await writeWithBackpressure(
+    options.response,
+    `event: ${options.type}
+data: ${prefix.slice(0, markerAt)}"`,
+    options.signal
+  );
+  const reader = (await options.spool.open(options.signal)).getReader();
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      await writeWithBackpressure(options.response, next.value, options.signal);
+    }
+  } finally {
+    await reader.cancel().catch(() => void 0);
+    reader.releaseLock();
+  }
+  const suffixObject = options.afterImage ?? {};
+  const suffix = JSON.stringify(suffixObject);
+  await writeWithBackpressure(
+    options.response,
+    `"${prefix.slice(markerAt + marker.length, -1)}${suffix === "{}" ? "" : `,${suffix.slice(1, -1)}`}}
+
+`,
+    options.signal
+  );
+}
+async function emitOutput(options) {
+  const spool = await stageAsset(options.output.artifact, options.scope, options.limits, options.signal);
+  try {
+    await writeAssetFrame({
+      response: options.response,
+      spool,
+      type: options.type,
+      beforeImage: {
+        output_index: options.outputIndex,
+        ...options.partialImageIndex !== void 0 ? { partial_image_index: options.partialImageIndex } : {}
+      },
+      afterImage: {
+        ...options.output.revisedPrompt !== void 0 ? { revised_prompt: options.output.revisedPrompt } : {},
+        ...options.finalFields ?? {}
+      },
+      signal: options.signal
+    });
+  } finally {
+    await spool.dispose();
+  }
+}
+async function writeImageApiSse(options) {
+  const prefix = options.action === "generation" ? "image_generation" : "image_edit";
+  let accepted = false;
+  let completed = false;
+  try {
+    for await (const event of options.events) {
+      if (options.signal.aborted) cancelled3(options.signal);
+      if (event.type === "accepted") {
+        if (accepted) throw new ImageGenerationError("upstream_protocol_changed");
+        accepted = true;
+        options.response.writeHead(200, {
+          "Content-Type": "text/event-stream; charset=utf-8",
+          "Cache-Control": "no-cache, no-transform",
+          Connection: "keep-alive",
+          "x-request-id": safeImageRequestId(options.requestId)
+        });
+        options.response.flushHeaders();
+        continue;
+      }
+      if (event.type === "failed") throw imageApiErrorFromProvider(event.error);
+      if (!accepted) throw new ImageGenerationError("upstream_protocol_changed");
+      if (event.type === "partial_image") {
+        await emitOutput({
+          response: options.response,
+          output: event.image,
+          type: `${prefix}.partial_image`,
+          outputIndex: event.outputIndex,
+          partialImageIndex: event.partialImageIndex,
+          finalFields: {
+            background: options.metadata.background,
+            created_at: Math.floor(options.createdAt / 1e3),
+            output_format: options.metadata.outputFormat,
+            quality: options.metadata.quality,
+            size: options.metadata.size
+          },
+          scope: options.scope,
+          limits: options.limits,
+          signal: options.signal
+        });
+        continue;
+      }
+      if (event.images.length !== options.requestedCount) {
+        throw new ImageGenerationError("upstream_protocol_changed");
+      }
+      const total = event.images.reduce((sum, output) => sum + output.artifact.byteLength, 0);
+      if (!Number.isSafeInteger(total) || total > options.limits.maxTotalOutputBytes) {
+        throw new ImageGenerationError("image_too_large");
+      }
+      const usage = outputUsage(event.usage);
+      for (let index = 0; index < event.images.length; index += 1) {
+        await emitOutput({
+          response: options.response,
+          output: event.images[index],
+          type: `${prefix}.completed`,
+          outputIndex: index,
+          finalFields: {
+            background: options.metadata.background,
+            created_at: Math.floor(options.createdAt / 1e3),
+            output_format: options.metadata.outputFormat,
+            quality: options.metadata.quality,
+            size: options.metadata.size,
+            ...index === event.images.length - 1 && usage ? { usage } : {}
+          },
+          scope: options.scope,
+          limits: options.limits,
+          signal: options.signal
+        });
+      }
+      completed = true;
+    }
+    if (!completed) throw new ImageGenerationError("upstream_protocol_changed");
+    if (!options.response.writableEnded) options.response.end();
+  } catch (error) {
+    const mapped = serializeImageApiError(error);
+    if (!accepted) throw mapped.domainError;
+    if (mapped.domainError.code !== "request_cancelled" && !options.signal.aborted && !options.response.destroyed && !options.response.writableEnded) {
+      const body = JSON.stringify({ type: "error", error: mapped.body.error });
+      await writeWithBackpressure(options.response, `event: error
+data: ${body}
+
+`, options.signal).catch(() => void 0);
+      options.response.end();
+    }
+    throw mapped.domainError;
+  }
+}
+
+// src/image-generation/openai-images/normalizeOptions.ts
+var OPTION_KEYS = /* @__PURE__ */ new Set([
+  "prompt",
+  "model",
+  "n",
+  "quality",
+  "size",
+  "background",
+  "output_format",
+  "output_compression",
+  "moderation",
+  "stream",
+  "partial_images",
+  "user"
+]);
+function invalid(param) {
+  throw new ImageGenerationError("invalid_image_request", { param });
+}
+function recordOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid();
+  return value;
+}
+function scalar(value, multipart) {
+  if (!multipart || typeof value !== "string") return value;
+  return value.trim();
+}
+function integer(value, fallback, param, min, max, multipart) {
+  const item = scalar(value, multipart);
+  const parsed = typeof item === "string" && /^\d+$/.test(item) ? Number(item) : item;
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) invalid(param);
+  return parsed;
+}
+function booleanValue(value, fallback, param, multipart) {
+  if (value === void 0) return fallback;
+  const item = scalar(value, multipart);
+  if (item === true || item === "true") return true;
+  if (item === false || item === "false") return false;
+  return invalid(param);
+}
+function enumValue(value, fallback, allowed, param, multipart) {
+  if (value === void 0) return fallback;
+  const item = scalar(value, multipart);
+  if (typeof item !== "string" || !allowed.includes(item)) invalid(param);
+  return item;
+}
+function parseSize(value, multipart) {
+  if (value === void 0 || scalar(value, multipart) === "auto") return { kind: "auto" };
+  const item = scalar(value, multipart);
+  if (typeof item !== "string") invalid("size");
+  const match = /^(\d+)x(\d+)$/.exec(item);
+  if (!match) invalid("size");
+  const width = Number(match[1]);
+  const height = Number(match[2]);
+  const pixels = width * height;
+  const long = Math.max(width, height);
+  const short = Math.min(width, height);
+  if (!Number.isSafeInteger(pixels) || width % 16 !== 0 || height % 16 !== 0 || width <= 0 || height <= 0 || long > 3840 || long / short > 3 || pixels < 655360 || pixels > 8294400) invalid("size");
+  return { kind: "pixels", width, height };
+}
+function normalizeImageOptions(value, runtime, input) {
+  const record2 = recordOf(value);
+  const allowed = /* @__PURE__ */ new Set([...OPTION_KEYS, ...input.extraKeys ?? []]);
+  for (const key of Object.keys(record2)) {
+    if (!allowed.has(key)) invalid(key);
+  }
+  const multipart = input.multipart === true;
+  const promptValue = scalar(record2.prompt, multipart);
+  if (typeof promptValue !== "string" || !promptValue.trim() || promptValue.length > 32e3) {
+    invalid("prompt");
+  }
+  const requestedModel = record2.model === void 0 ? runtime.defaultModel : scalar(record2.model, multipart);
+  if (typeof requestedModel !== "string" || !requestedModel.trim() || requestedModel.length > 128) {
+    invalid("model");
+  }
+  const model = runtime.modelAliases.get(requestedModel) ?? requestedModel;
+  const n = integer(record2.n, 1, "n", 1, 10, multipart);
+  const quality = enumValue(record2.quality, "auto", ["auto", "low", "medium", "high"], "quality", multipart);
+  const size = parseSize(record2.size, multipart);
+  const background = enumValue(record2.background, "auto", ["auto", "opaque", "transparent"], "background", multipart);
+  const outputFormat = enumValue(record2.output_format, "png", ["png", "jpeg", "webp"], "output_format", multipart);
+  const outputCompression = record2.output_compression === void 0 ? void 0 : integer(record2.output_compression, 0, "output_compression", 0, 100, multipart);
+  const moderation = enumValue(record2.moderation, "auto", ["auto", "low"], "moderation", multipart);
+  const stream = booleanValue(record2.stream, false, "stream", multipart);
+  const partialImages = integer(record2.partial_images, 0, "partial_images", 0, 3, multipart);
+  if (background === "transparent" && outputFormat === "jpeg") invalid("background");
+  if (outputCompression !== void 0 && outputFormat === "png") invalid("output_compression");
+  if (partialImages > 0 && !stream) invalid("partial_images");
+  let userFingerprint;
+  if (record2.user !== void 0) {
+    const user = scalar(record2.user, multipart);
+    if (typeof user !== "string" || !user || user.length > 256) invalid("user");
+    if (runtime.fingerprintUser) {
+      const fingerprint = runtime.fingerprintUser(user);
+      if (typeof fingerprint !== "string" || !/^[A-Za-z0-9:_-]{1,128}$/.test(fingerprint)) {
+        throw new TypeError("The injected image user fingerprint is not a safe identifier.");
+      }
+      userFingerprint = fingerprint;
+    }
+  }
+  return {
+    model,
+    prompt: promptValue,
+    n,
+    quality,
+    size,
+    background,
+    outputFormat,
+    ...outputCompression !== void 0 ? { outputCompression } : {},
+    moderation,
+    stream,
+    partialImages,
+    ...userFingerprint !== void 0 ? { userFingerprint } : {}
+  };
+}
+function normalizeGenerateRequest(value, runtime) {
+  return { action: "generate", ...normalizeImageOptions(value, runtime, { action: "generate" }) };
+}
+
+// src/image-generation/openai-images/readJsonBody.ts
+function invalid2(param) {
+  throw new ImageGenerationError("invalid_image_request", { param });
+}
+function tooLarge2() {
+  throw new ImageGenerationError("image_too_large");
+}
+function mediaType(value) {
+  return (value ?? "").split(";", 1)[0].trim().toLowerCase();
+}
+function declaredLength(value, limit) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value) || !/^(0|[1-9]\d*)$/.test(value)) tooLarge2();
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0 || parsed > limit) tooLarge2();
+  return parsed;
+}
+async function readJsonBody(request2, options) {
+  if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes <= 0) {
+    throw new TypeError("The JSON body limit must be a positive safe integer.");
+  }
+  if (options.signal.aborted) {
+    throw new ImageGenerationError("request_cancelled", { cause: options.signal.reason });
+  }
+  if (mediaType(request2.headers["content-type"]) !== "application/json") invalid2("content_type");
+  const encoding = request2.headers["content-encoding"];
+  if (Array.isArray(encoding) || encoding !== void 0 && encoding.trim().toLowerCase() !== "identity") {
+    invalid2("content_encoding");
+  }
+  const expected = declaredLength(request2.headers["content-length"], options.maxBytes);
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+  const pieces = [];
+  let observed = 0;
+  const abort = () => {
+    request2.destroy(options.signal.reason instanceof Error ? options.signal.reason : void 0);
+  };
+  options.signal.addEventListener("abort", abort, { once: true });
+  try {
+    try {
+      for await (const raw of request2) {
+        if (options.signal.aborted) {
+          throw new ImageGenerationError("request_cancelled", { cause: options.signal.reason });
+        }
+        const chunk = raw instanceof Uint8Array ? raw : Buffer.from(raw);
+        observed += chunk.byteLength;
+        if (!Number.isSafeInteger(observed) || observed > options.maxBytes || expected !== void 0 && observed > expected) {
+          tooLarge2();
+        }
+        pieces.push(decoder.decode(chunk, { stream: true }));
+      }
+      pieces.push(decoder.decode());
+    } catch (error) {
+      if (options.signal.aborted) {
+        throw new ImageGenerationError("request_cancelled", { cause: options.signal.reason });
+      }
+      if (error instanceof ImageGenerationError) throw error;
+      invalid2();
+    }
+    if (observed === 0 || expected !== void 0 && observed !== expected) invalid2();
+    try {
+      return JSON.parse(pieces.join(""));
+    } catch {
+      invalid2();
+    }
+  } finally {
+    options.signal.removeEventListener("abort", abort);
+  }
+}
+
+// src/image-generation/openai-images/types.ts
+var DEFAULT_IMAGE_API_LIMITS = Object.freeze({
+  maxJsonBytes: 1024 * 1024,
+  maxMultipartBytes: 64 * 1024 * 1024,
+  maxFileBytes: 50 * 1024 * 1024,
+  maxTotalInputBytes: 64 * 1024 * 1024,
+  maxFiles: 17,
+  maxFields: 32,
+  maxParts: 49,
+  maxHeaderPairs: 64,
+  maxFieldNameBytes: 128,
+  maxFieldValueBytes: 32 * 1024,
+  maxPixels: 8294400,
+  maxRawBytes: 8294400 * 4,
+  maxOutputBytes: 50 * 1024 * 1024,
+  maxTotalOutputBytes: 100 * 1024 * 1024,
+  maxSpoolBytes: 140 * 1024 * 1024,
+  maxRedirects: 5,
+  maxRemoteUrlBytes: 8 * 1024,
+  maxRemoteHeaderBytes: 32 * 1024,
+  remoteConnectTimeoutMs: 1e4,
+  remoteTotalTimeoutMs: 3e4
+});
+function assertFiniteImageApiLimits(limits) {
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      throw new TypeError(`Image API limit '${name}' must be a positive safe integer.`);
+    }
+  }
+  if (limits.maxFileBytes > 50 * 1024 * 1024) {
+    throw new TypeError("Image API per-file limit exceeds the 50 MiB hard ceiling.");
+  }
+  if (limits.maxFiles > 17) {
+    throw new TypeError("Image API file count exceeds sixteen images plus one mask.");
+  }
+  if (limits.maxPixels > 8294400) {
+    throw new TypeError("Image API pixel limit exceeds the GPT Image hard ceiling.");
+  }
+  if (limits.maxTotalInputBytes < limits.maxFileBytes) {
+    throw new TypeError("Image API aggregate input limit must cover one file.");
+  }
+  if (limits.maxTotalOutputBytes < limits.maxOutputBytes) {
+    throw new TypeError("Image API aggregate output limit must cover one output.");
+  }
+}
+
+// src/image-generation/openai-images/generateHandler.ts
+function validateRuntime(runtime) {
+  if (typeof runtime.tenantId !== "string" || !runtime.tenantId || runtime.tenantId.length > 256 || typeof runtime.providerId !== "string" || !runtime.providerId || runtime.providerId.length > 128 || typeof runtime.defaultModel !== "string" || !runtime.defaultModel || runtime.defaultModel.length > 128 || !runtime.modelAliases || typeof runtime.modelAliases.get !== "function") {
+    throw new ImageGenerationError("invalid_api_key");
+  }
+  for (const hint of [runtime.preferredAccountId, runtime.preferredAccountGroup]) {
+    if (hint !== void 0 && (typeof hint !== "string" || !hint.trim() || hint.length > 256)) {
+      throw new ImageGenerationError("invalid_api_key");
+    }
+  }
+  if (runtime.boundAccountFallbackPolicy !== void 0 && runtime.boundAccountFallbackPolicy !== "strict" && runtime.boundAccountFallbackPolicy !== "pool") {
+    throw new ImageGenerationError("invalid_api_key");
+  }
+  assertFiniteImageApiLimits(runtime.limits);
+}
+async function bestEffortAudit(deps, record2) {
+  try {
+    await deps.audit?.(record2);
+  } catch {
+  }
+}
+function createImageGenerateHandler(deps) {
+  return async (context) => {
+    const requestId = safeImageRequestId(deps.createRequestId?.());
+    const createdAt = (deps.now ?? Date.now)();
+    let runtime;
+    let request2;
+    let scope;
+    let cleanupOutcome;
+    let terminal = "failed";
+    let terminalCode;
+    try {
+      runtime = await deps.resolveRuntime(context);
+      validateRuntime(runtime);
+      scope = deps.createResourceScope ? await deps.createResourceScope(runtime.limits, context.signal, runtime.tenantId) : await createImageRequestResourceScope(runtime.limits, context.signal);
+      const body = await readJsonBody(context.request, {
+        maxBytes: runtime.limits.maxJsonBytes,
+        signal: context.signal
+      });
+      request2 = normalizeGenerateRequest(body, runtime);
+      const events = deps.orchestrator.run(
+        request2,
+        {
+          requestId,
+          tenantId: runtime.tenantId,
+          signal: context.signal,
+          ...context.route.sessionId ? { sessionKey: context.route.sessionId } : {},
+          ...runtime.preferredAccountId ? { preferredAccountId: runtime.preferredAccountId } : {},
+          ...runtime.preferredAccountGroup ? { preferredAccountGroup: runtime.preferredAccountGroup } : {},
+          ...runtime.boundAccountFallbackPolicy ? { boundAccountFallbackPolicy: runtime.boundAccountFallbackPolicy } : {}
+        },
+        { providerId: runtime.providerId, ...runtime.retention ? { retention: runtime.retention } : {} }
+      );
+      if (request2.stream) {
+        await writeImageApiSse({
+          action: "generation",
+          response: context.response,
+          events,
+          requestedCount: request2.n,
+          requestId,
+          createdAt,
+          metadata: {
+            background: request2.background,
+            outputFormat: request2.outputFormat,
+            quality: request2.quality,
+            size: request2.size.kind === "auto" ? "auto" : `${request2.size.width}x${request2.size.height}`
+          },
+          scope,
+          limits: runtime.limits,
+          signal: context.signal
+        });
+      } else {
+        await writeImageApiResponse({
+          response: context.response,
+          events,
+          requestedCount: request2.n,
+          requestId,
+          createdAt,
+          scope,
+          limits: runtime.limits,
+          signal: context.signal
+        });
+      }
+      terminal = "completed";
+    } catch (error) {
+      const domainError = imageApiErrorFromUnknown(error);
+      terminal = domainError.code === "request_cancelled" ? "cancelled" : "failed";
+      terminalCode = domainError.code;
+      writeImageApiError(context.response, domainError, requestId);
+    } finally {
+      if (scope) {
+        try {
+          await scope.cleanup();
+          cleanupOutcome = "completed";
+        } catch {
+          cleanupOutcome = "failed";
+        }
+      }
+      await bestEffortAudit(deps, {
+        requestId,
+        operationId: "images.generate",
+        ...runtime ? { providerId: runtime.providerId } : {},
+        ...request2 ? {
+          model: request2.model,
+          options: {
+            n: request2.n,
+            quality: request2.quality,
+            background: request2.background,
+            outputFormat: request2.outputFormat,
+            stream: request2.stream,
+            partialImages: request2.partialImages
+          }
+        } : {},
+        terminal,
+        ...cleanupOutcome ? { cleanupOutcome } : {},
+        ...terminalCode ? { errorCode: terminalCode } : {}
+      });
+    }
+  };
+}
+
+// src/image-generation/openai-images/readMultipartEdit.ts
+import Busboy from "busboy";
+
+// src/image-generation/openai-images/validateRaster.ts
+import { createHash } from "crypto";
+import { open as open2, readFile } from "fs/promises";
+import sharp from "sharp";
+function unsupported2() {
+  throw new ImageGenerationError("unsupported_image_type");
+}
+function tooLarge3() {
+  throw new ImageGenerationError("image_too_large");
+}
+function hasPrefix(bytes, signature) {
+  return signature.every((value, index) => bytes[index] === value);
+}
+function signatureFormat(header) {
+  if (hasPrefix(header, [137, 80, 78, 71, 13, 10, 26, 10])) return "png";
+  if (hasPrefix(header, [255, 216, 255])) return "jpeg";
+  if (hasPrefix(header, [82, 73, 70, 70]) && header[8] === 87 && header[9] === 69 && header[10] === 66 && header[11] === 80) return "webp";
+  unsupported2();
+}
+async function inspectContainer(privatePath, byteLength2) {
+  if (byteLength2 < 12) unsupported2();
+  const handle = await open2(privatePath, "r");
+  try {
+    const header = Buffer.allocUnsafe(12);
+    const headerRead = await handle.read(header, 0, header.byteLength, 0);
+    if (headerRead.bytesRead !== header.byteLength) unsupported2();
+    const format = signatureFormat(header);
+    if (format === "png") {
+      if (byteLength2 < 20) unsupported2();
+      const trailer = Buffer.allocUnsafe(12);
+      const result = await handle.read(trailer, 0, trailer.byteLength, byteLength2 - trailer.byteLength);
+      if (result.bytesRead !== trailer.byteLength || trailer.readUInt32BE(0) !== 0 || trailer.toString("ascii", 4, 8) !== "IEND" || !hasPrefix(trailer.subarray(8), [174, 66, 96, 130])) unsupported2();
+    } else if (format === "jpeg") {
+      const trailer = Buffer.allocUnsafe(2);
+      const result = await handle.read(trailer, 0, 2, byteLength2 - 2);
+      if (result.bytesRead !== 2 || trailer[0] !== 255 || trailer[1] !== 217) unsupported2();
+    } else {
+      const declared = header.readUInt32LE(4) + 8;
+      if (declared !== byteLength2) unsupported2();
+    }
+    return format;
+  } finally {
+    await handle.close();
+  }
+}
+function mapSharpFailure(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : "";
+  if (message.includes("pixel limit") || message.includes("memory") || message.includes("too large")) tooLarge3();
+  unsupported2();
+}
+async function validateRaster(file, limits) {
+  if (file.byteLength > limits.maxFileBytes) tooLarge3();
+  const metadata = await file.inspect(async (privatePath) => {
+    const format = await inspectContainer(privatePath, file.byteLength);
+    const encoded = await readFile(privatePath);
+    if (encoded.byteLength !== file.byteLength) unsupported2();
+    try {
+      const image = sharp(encoded, {
+        failOn: "warning",
+        sequentialRead: true,
+        limitInputPixels: limits.maxPixels,
+        pages: 1,
+        animated: false
+      });
+      const info = await image.metadata();
+      image.destroy();
+      if (info.format !== format) unsupported2();
+      if ((info.pages ?? 1) !== 1 || info.pageHeight !== void 0 && info.height !== info.pageHeight) unsupported2();
+      const width = info.width;
+      const height = info.height;
+      const channels = info.channels;
+      if (!width || !height || !channels || !Number.isSafeInteger(width) || !Number.isSafeInteger(height) || !Number.isSafeInteger(channels)) unsupported2();
+      const pixels = width * height;
+      const rawBytes = pixels * channels;
+      if (!Number.isSafeInteger(pixels) || pixels <= 0 || pixels > limits.maxPixels || !Number.isSafeInteger(rawBytes) || rawBytes <= 0 || rawBytes > limits.maxRawBytes) tooLarge3();
+      const decoder = sharp(encoded, {
+        failOn: "warning",
+        sequentialRead: true,
+        limitInputPixels: limits.maxPixels,
+        pages: 1,
+        animated: false
+      }).raw();
+      const decoded = await decoder.toBuffer({ resolveWithObject: true });
+      decoder.destroy();
+      if (decoded.info.width !== width || decoded.info.height !== height || decoded.info.channels !== channels || decoded.data.byteLength !== rawBytes) unsupported2();
+      return {
+        format,
+        mimeType: `image/${format}`,
+        width,
+        height,
+        hasAlpha: info.hasAlpha === true,
+        sha256: createHash("sha256").update(encoded).digest("hex")
+      };
+    } catch (error) {
+      if (error instanceof ImageGenerationError) throw error;
+      mapSharpFailure(error);
+    }
+  });
+  return file.toImageAsset(metadata);
+}
+function assertCompatibleMask(primary, mask) {
+  if (mask.mimeType !== primary.mimeType || mask.width !== primary.width || mask.height !== primary.height || mask.hasAlpha !== true) {
+    throw new ImageGenerationError("invalid_image_request", { param: "mask" });
+  }
+}
+
+// src/image-generation/openai-images/readMultipartEdit.ts
+function invalid3(param) {
+  return new ImageGenerationError("invalid_image_request", { param });
+}
+function tooLarge4() {
+  return new ImageGenerationError("image_too_large");
+}
+function declaredLength2(value, limit) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value) || !/^(0|[1-9]\d*)$/.test(value)) throw tooLarge4();
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0 || parsed > limit) throw tooLarge4();
+  return parsed;
+}
+function byteLength(value) {
+  return Buffer.byteLength(value, "utf8");
+}
+var MAX_MULTIPART_HEADER_BYTES = 16 * 1024;
+function multipartBoundary(contentType) {
+  const match = /(?:^|;)\s*boundary=(?:"([^"]*)"|([^;\s]*))/i.exec(contentType);
+  const boundary = match?.[1] ?? match?.[2];
+  if (!boundary || boundary.length > 200 || !/^[\x20-\x7e]+$/.test(boundary) || boundary.endsWith(" ")) {
+    throw invalid3("content_type");
+  }
+  return boundary;
+}
+var MultipartHeaderPairGuard = class {
+  #opening;
+  #betweenParts;
+  #maxPairs;
+  #state = "preamble";
+  #pending = Buffer.alloc(0);
+  constructor(boundary, maxPairs) {
+    this.#opening = Buffer.from(`--${boundary}`, "latin1");
+    this.#betweenParts = Buffer.from(`\r
+--${boundary}`, "latin1");
+    this.#maxPairs = maxPairs;
+  }
+  push(chunk) {
+    if (this.#state === "done") return;
+    let data = this.#pending.length === 0 ? Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength) : Buffer.concat([this.#pending, Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)]);
+    this.#pending = Buffer.alloc(0);
+    while (data.length > 0) {
+      if (this.#state === "preamble") {
+        const start = data.indexOf(this.#opening);
+        if (start < 0) {
+          if (data.length > MAX_MULTIPART_HEADER_BYTES) throw tooLarge4();
+          this.#pending = Buffer.from(data);
+          return;
+        }
+        data = data.subarray(start + this.#opening.length);
+        if (data.length < 2) {
+          this.#pending = Buffer.concat([this.#opening, data]);
+          return;
+        }
+        if (data[0] === 45 && data[1] === 45) {
+          this.#state = "done";
+          return;
+        }
+        if (data[0] !== 13 || data[1] !== 10) throw invalid3("content_type");
+        data = data.subarray(2);
+        this.#state = "headers";
+        continue;
+      }
+      if (this.#state === "headers") {
+        const end = data.indexOf("\r\n\r\n");
+        if (end < 0) {
+          if (data.length > MAX_MULTIPART_HEADER_BYTES) throw tooLarge4();
+          this.#pending = Buffer.from(data);
+          return;
+        }
+        const block = data.subarray(0, end);
+        const pairs = block.length === 0 ? 0 : block.toString("latin1").split("\r\n").length;
+        if (pairs > this.#maxPairs) throw tooLarge4();
+        data = data.subarray(end + 4);
+        this.#state = "body";
+        continue;
+      }
+      let searchFrom = 0;
+      let boundaryAt = -1;
+      while ((boundaryAt = data.indexOf(this.#betweenParts, searchFrom)) >= 0) {
+        const suffix2 = boundaryAt + this.#betweenParts.length;
+        if (data.length < suffix2 + 2) {
+          this.#pending = Buffer.from(data.subarray(boundaryAt));
+          return;
+        }
+        if (data[suffix2] === 45 && data[suffix2 + 1] === 45 || data[suffix2] === 13 && data[suffix2 + 1] === 10) break;
+        searchFrom = boundaryAt + 1;
+      }
+      if (boundaryAt < 0) {
+        const keep = Math.min(data.length, this.#betweenParts.length - 1);
+        this.#pending = Buffer.from(data.subarray(data.length - keep));
+        return;
+      }
+      const suffix = boundaryAt + this.#betweenParts.length;
+      if (data[suffix] === 45 && data[suffix + 1] === 45) {
+        this.#state = "done";
+        return;
+      }
+      data = data.subarray(suffix + 2);
+      this.#state = "headers";
+    }
+  }
+  finish() {
+    if (this.#state !== "done") throw invalid3();
+  }
+};
+async function readMultipartEdit(request2, scope, limits, signal) {
+  if (signal.aborted) throw new ImageGenerationError("request_cancelled", { cause: signal.reason });
+  const contentType = request2.headers["content-type"];
+  if (typeof contentType !== "string" || !/^multipart\/form-data(?:\s*;|$)/i.test(contentType)) {
+    throw invalid3("content_type");
+  }
+  const encoding = request2.headers["content-encoding"];
+  if (Array.isArray(encoding) || encoding !== void 0 && encoding.trim().toLowerCase() !== "identity") {
+    throw invalid3("content_encoding");
+  }
+  const expected = declaredLength2(request2.headers["content-length"], limits.maxMultipartBytes);
+  const headerGuard = new MultipartHeaderPairGuard(
+    multipartBoundary(contentType),
+    limits.maxHeaderPairs
+  );
+  const fields = /* @__PURE__ */ Object.create(null);
+  const pending = [];
+  let imageCount = 0;
+  let maskCount = 0;
+  let observed = 0;
+  let settled = false;
+  let parser;
+  try {
+    parser = Busboy({
+      headers: request2.headers,
+      limits: {
+        fileSize: limits.maxFileBytes,
+        files: limits.maxFiles,
+        fields: limits.maxFields,
+        parts: limits.maxParts,
+        headerPairs: limits.maxHeaderPairs,
+        fieldNameSize: limits.maxFieldNameBytes,
+        fieldSize: limits.maxFieldValueBytes
+      }
+    });
+  } catch {
+    throw invalid3("content_type");
+  }
+  const parsed = new Promise((resolve2, reject) => {
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      request2.unpipe(parser);
+      request2.pause();
+      parser.destroy(error instanceof Error ? error : invalid3());
+      reject(error);
+    };
+    const onAbort = () => fail(new ImageGenerationError("request_cancelled", { cause: signal.reason }));
+    let requestEnded = false;
+    const onEnd = () => {
+      requestEnded = true;
+    };
+    const onClose = () => {
+      if (!requestEnded) fail(invalid3());
+    };
+    const onRequestError = () => fail(invalid3());
+    const onData = (chunk) => {
+      observed += chunk.byteLength;
+      if (!Number.isSafeInteger(observed) || observed > limits.maxMultipartBytes || expected !== void 0 && observed > expected) {
+        fail(tooLarge4());
+        return;
+      }
+      try {
+        headerGuard.push(chunk);
+      } catch (error) {
+        fail(error);
+      }
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    request2.on("data", onData);
+    request2.once("aborted", onAbort);
+    request2.once("end", onEnd);
+    request2.once("close", onClose);
+    request2.once("error", onRequestError);
+    parser.on("file", (name, file) => {
+      if (settled) {
+        file.resume();
+        return;
+      }
+      if (byteLength(name) > limits.maxFieldNameBytes) {
+        file.resume();
+        fail(tooLarge4());
+        return;
+      }
+      let kind;
+      if (name === "image" || name === "image[]") {
+        imageCount += 1;
+        if (imageCount > 16) {
+          file.resume();
+          fail(invalid3("image"));
+          return;
+        }
+        kind = "image";
+      } else if (name === "mask") {
+        maskCount += 1;
+        if (maskCount > 1) {
+          file.resume();
+          fail(invalid3("mask"));
+          return;
+        }
+        kind = "mask";
+      } else {
+        file.resume();
+        fail(invalid3(name.length <= 128 ? name : void 0));
+        return;
+      }
+      let truncated = false;
+      file.once("limit", () => {
+        truncated = true;
+      });
+      const staged2 = scope.materialize(file, {
+        maxBytes: limits.maxFileBytes,
+        signal
+      }).then((value) => {
+        if (truncated || file.truncated) throw tooLarge4();
+        return value;
+      });
+      staged2.catch(fail);
+      pending.push({ kind, staged: staged2 });
+    });
+    parser.on("field", (name, value, info) => {
+      if (settled) return;
+      if (info.nameTruncated || info.valueTruncated || byteLength(name) > limits.maxFieldNameBytes || byteLength(value) > limits.maxFieldValueBytes) {
+        fail(tooLarge4());
+        return;
+      }
+      if (Object.hasOwn(fields, name)) {
+        fail(invalid3(name.length <= 128 ? name : void 0));
+        return;
+      }
+      fields[name] = value;
+    });
+    parser.once("filesLimit", () => fail(tooLarge4()));
+    parser.once("fieldsLimit", () => fail(tooLarge4()));
+    parser.once("partsLimit", () => fail(tooLarge4()));
+    parser.once("error", (error) => fail(error instanceof ImageGenerationError ? error : invalid3()));
+    parser.once("finish", () => {
+      if (settled) return;
+      try {
+        headerGuard.finish();
+      } catch (error) {
+        fail(error);
+        return;
+      }
+      if (expected !== void 0 && observed !== expected) {
+        fail(invalid3());
+        return;
+      }
+      settled = true;
+      resolve2();
+    });
+    request2.pipe(parser);
+    const cleanup = () => {
+      signal.removeEventListener("abort", onAbort);
+      request2.removeListener("data", onData);
+      request2.removeListener("aborted", onAbort);
+      request2.removeListener("end", onEnd);
+      request2.removeListener("close", onClose);
+      request2.removeListener("error", onRequestError);
+    };
+    parser.once("close", cleanup);
+  });
+  await parsed;
+  if (imageCount < 1 || imageCount > 16) throw invalid3("image");
+  const staged = await Promise.all(pending.map((item) => item.staged));
+  const images = [];
+  let mask;
+  for (let index = 0; index < staged.length; index += 1) {
+    const asset = await validateRaster(staged[index], limits);
+    if (pending[index].kind === "mask") mask = asset;
+    else images.push(asset);
+  }
+  if (mask) assertCompatibleMask(images[0], mask);
+  return { fields, images, ...mask ? { mask } : {} };
+}
+
+// src/image-generation/openai-images/resolveImageInput.ts
+function invalid4(param = "image") {
+  throw new ImageGenerationError("invalid_image_request", { param });
+}
+function closedInput(value, maxRemoteUrlBytes) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid4();
+  const record2 = value;
+  const keys = Object.keys(record2);
+  if (keys.length !== 1) invalid4();
+  const key = keys[0];
+  if (key !== "file_id" && key !== "image_url") invalid4();
+  const item = record2[key];
+  const maxBytes = key === "file_id" ? 256 : maxRemoteUrlBytes;
+  if (typeof item !== "string" || !item || Buffer.byteLength(item, "utf8") > maxBytes) invalid4();
+  return { [key]: item };
+}
+function decodedBase64Length(value) {
+  if (value.length === 0 || value.length % 4 !== 0) invalid4();
+  let padding = 0;
+  if (value.charCodeAt(value.length - 1) === 61) padding += 1;
+  if (value.charCodeAt(value.length - 2) === 61) padding += 1;
+  const decoded = value.length / 4 * 3 - padding;
+  if (!Number.isSafeInteger(decoded) || decoded <= 0) invalid4();
+  return decoded;
+}
+function validateBase64(value, padding) {
+  const alphabetEnd = value.length - padding;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    const alphabet = code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || code === 43 || code === 47;
+    if (index < alphabetEnd ? !alphabet : code !== 61) invalid4();
+  }
+  const alphabetValue = (code) => {
+    if (code >= 65 && code <= 90) return code - 65;
+    if (code >= 97 && code <= 122) return code - 97 + 26;
+    if (code >= 48 && code <= 57) return code - 48 + 52;
+    return code === 43 ? 62 : 63;
+  };
+  if (padding === 1 && (alphabetValue(value.charCodeAt(value.length - 2)) & 3) !== 0) invalid4();
+  if (padding === 2 && (alphabetValue(value.charCodeAt(value.length - 3)) & 15) !== 0) invalid4();
+}
+async function* decodeBase64Chunks(value) {
+  const blockCharacters = 64 * 1024;
+  for (let offset = 0; offset < value.length; offset += blockCharacters) {
+    const end = Math.min(value.length, offset + blockCharacters);
+    yield Buffer.from(value.slice(offset, end), "base64");
+  }
+}
+async function resolveDataUrl(value, runtime, scope, signal) {
+  const comma = value.indexOf(",");
+  if (comma < 0) invalid4();
+  const descriptor = value.slice(0, comma).toLowerCase();
+  if (!["data:image/png;base64", "data:image/jpeg;base64", "data:image/webp;base64"].includes(descriptor)) {
+    invalid4();
+  }
+  const encoded = value.slice(comma + 1);
+  const decoded = decodedBase64Length(encoded);
+  if (decoded > runtime.limits.maxFileBytes) throw new ImageGenerationError("image_too_large");
+  const padding = encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0;
+  validateBase64(encoded, padding);
+  const file = await scope.materialize(decodeBase64Chunks(encoded), {
+    declaredBytes: decoded,
+    maxBytes: runtime.limits.maxFileBytes,
+    signal
+  });
+  return validateRaster(file, runtime.limits);
+}
+async function resolveReference(referenceId, runtime, scope) {
+  if (!runtime.referenceStore) throw new ImageGenerationError("unsupported_capability", { param: "file_id" });
+  const result = await runtime.referenceStore.resolve(runtime.tenantId, referenceId);
+  if (result.status === "not_found") throw new ImageGenerationError("image_reference_not_found", { param: "file_id" });
+  if (result.status === "expired") throw new ImageGenerationError("image_reference_expired", { param: "file_id" });
+  const asset = result.lease.value.artifact;
+  if (!asset) {
+    await result.lease.release();
+    throw new ImageGenerationError("unsupported_capability", { param: "file_id" });
+  }
+  if (asset.byteLength !== result.lease.metadata.byteLength || asset.width !== result.lease.metadata.width || asset.height !== result.lease.metadata.height || asset.mimeType !== result.lease.metadata.mimeType) {
+    await result.lease.release();
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  scope.addLease(result.lease);
+  return asset;
+}
+async function resolveImageInput(value, runtime, scope, signal) {
+  const input = closedInput(value, runtime.limits.maxRemoteUrlBytes);
+  if ("file_id" in input) return resolveReference(input.file_id, runtime, scope);
+  if (input.image_url.toLowerCase().startsWith("data:")) {
+    return resolveDataUrl(input.image_url, runtime, scope, signal);
+  }
+  if (!runtime.remoteResolver) {
+    throw new ImageGenerationError("unsupported_capability", { param: "image_url" });
+  }
+  const materializer = {
+    async materialize(source, declaredBytes, remoteSignal) {
+      const file = await scope.materialize(source, {
+        maxBytes: runtime.limits.maxFileBytes,
+        ...declaredBytes !== void 0 ? { declaredBytes } : {},
+        signal: remoteSignal
+      });
+      return validateRaster(file, runtime.limits);
+    }
+  };
+  return runtime.remoteResolver.resolve({
+    url: input.image_url,
+    signal,
+    limits: runtime.limits,
+    materializer
+  });
+}
+function parseImageInputList(value, maxRemoteUrlBytes) {
+  const list = Array.isArray(value) ? value : [value];
+  if (list.length < 1 || list.length > 16) invalid4();
+  for (const item of list) closedInput(item, maxRemoteUrlBytes);
+  return list;
+}
+
+// src/image-generation/openai-images/editHandler.ts
+function mediaType2(value) {
+  return (value ?? "").split(";", 1)[0].trim().toLowerCase();
+}
+function isReferenceInput(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.prototype.hasOwnProperty.call(value, "file_id");
+}
+function createImageEditHandler(deps) {
+  return async (context) => {
+    const requestId = safeImageRequestId(deps.createRequestId?.());
+    const createdAt = (deps.now ?? Date.now)();
+    let runtime;
+    let request2;
+    let scope;
+    let cleanupOutcome;
+    let observedReference = false;
+    const referenceOutcomes = { hits: 0, notFound: 0, expired: 0, failed: 0 };
+    let terminal = "failed";
+    let terminalCode;
+    try {
+      runtime = await deps.resolveRuntime(context);
+      validateRuntime(runtime);
+      scope = deps.createResourceScope ? await deps.createResourceScope(runtime.limits, context.signal, runtime.tenantId) : await createImageRequestResourceScope(runtime.limits, context.signal);
+      const type = mediaType2(context.request.headers["content-type"]);
+      if (type === "application/json") {
+        const value = await readJsonBody(context.request, {
+          maxBytes: runtime.limits.maxJsonBytes,
+          signal: context.signal
+        });
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+          throw new ImageGenerationError("invalid_image_request");
+        }
+        const record2 = value;
+        if (record2.image !== void 0 && record2.images !== void 0) {
+          throw new ImageGenerationError("invalid_image_request", { param: "image" });
+        }
+        const options = normalizeImageOptions(record2, runtime, {
+          action: "edit",
+          extraKeys: ["image", "images", "mask"]
+        });
+        const inputs = parseImageInputList(
+          record2.images ?? record2.image,
+          runtime.limits.maxRemoteUrlBytes
+        );
+        const resolveObservedInput = async (input) => {
+          const reference = isReferenceInput(input);
+          if (reference) observedReference = true;
+          try {
+            const asset = await resolveImageInput(input, runtime, scope, context.signal);
+            if (reference) referenceOutcomes.hits += 1;
+            return asset;
+          } catch (error) {
+            if (reference) {
+              if (error instanceof ImageGenerationError && error.code === "image_reference_not_found") {
+                referenceOutcomes.notFound += 1;
+              } else if (error instanceof ImageGenerationError && error.code === "image_reference_expired") {
+                referenceOutcomes.expired += 1;
+              } else {
+                referenceOutcomes.failed += 1;
+              }
+            }
+            throw error;
+          }
+        };
+        const images = [];
+        for (const input of inputs) images.push(await resolveObservedInput(input));
+        const mask = record2.mask === void 0 ? void 0 : await resolveObservedInput(record2.mask);
+        if (mask) assertCompatibleMask(images[0], mask);
+        request2 = { action: "edit", ...options, images, ...mask ? { mask } : {} };
+      } else {
+        const multipart = await readMultipartEdit(context.request, scope, runtime.limits, context.signal);
+        const options = normalizeImageOptions(multipart.fields, runtime, {
+          action: "edit",
+          multipart: true
+        });
+        request2 = {
+          action: "edit",
+          ...options,
+          images: multipart.images,
+          ...multipart.mask ? { mask: multipart.mask } : {}
+        };
+      }
+      const events = deps.orchestrator.run(
+        request2,
+        {
+          requestId,
+          tenantId: runtime.tenantId,
+          signal: context.signal,
+          ...context.route.sessionId ? { sessionKey: context.route.sessionId } : {},
+          ...runtime.preferredAccountId ? { preferredAccountId: runtime.preferredAccountId } : {},
+          ...runtime.preferredAccountGroup ? { preferredAccountGroup: runtime.preferredAccountGroup } : {},
+          ...runtime.boundAccountFallbackPolicy ? { boundAccountFallbackPolicy: runtime.boundAccountFallbackPolicy } : {}
+        },
+        { providerId: runtime.providerId, ...runtime.retention ? { retention: runtime.retention } : {} }
+      );
+      if (request2.stream) {
+        await writeImageApiSse({
+          action: "edit",
+          response: context.response,
+          events,
+          requestedCount: request2.n,
+          requestId,
+          createdAt,
+          metadata: {
+            background: request2.background,
+            outputFormat: request2.outputFormat,
+            quality: request2.quality,
+            size: request2.size.kind === "auto" ? "auto" : `${request2.size.width}x${request2.size.height}`
+          },
+          scope,
+          limits: runtime.limits,
+          signal: context.signal
+        });
+      } else {
+        await writeImageApiResponse({
+          response: context.response,
+          events,
+          requestedCount: request2.n,
+          requestId,
+          createdAt,
+          scope,
+          limits: runtime.limits,
+          signal: context.signal
+        });
+      }
+      terminal = "completed";
+    } catch (error) {
+      const domainError = imageApiErrorFromUnknown(error);
+      terminal = domainError.code === "request_cancelled" ? "cancelled" : "failed";
+      terminalCode = domainError.code;
+      writeImageApiError(context.response, domainError, requestId);
+    } finally {
+      if (scope) {
+        try {
+          await scope.cleanup();
+          cleanupOutcome = "completed";
+        } catch {
+          cleanupOutcome = "failed";
+        }
+      }
+      await bestEffortAudit(deps, {
+        requestId,
+        operationId: "images.edit",
+        ...runtime ? { providerId: runtime.providerId } : {},
+        ...request2 ? {
+          model: request2.model,
+          options: {
+            n: request2.n,
+            quality: request2.quality,
+            background: request2.background,
+            outputFormat: request2.outputFormat,
+            stream: request2.stream,
+            partialImages: request2.partialImages
+          },
+          inputCount: request2.images.length,
+          inputBytes: request2.images.reduce((sum, asset) => sum + asset.byteLength, 0)
+        } : {},
+        terminal,
+        ...observedReference ? { referenceOutcomes } : {},
+        ...cleanupOutcome ? { cleanupOutcome } : {},
+        ...terminalCode ? { errorCode: terminalCode } : {}
+      });
+    }
+  };
+}
+
+// src/image-generation/openai-images/contributions.ts
+function createImageApiContributions(deps) {
+  if (!deps || typeof deps !== "object" || !deps.orchestrator || typeof deps.resolveRuntime !== "function") {
+    throw new TypeError("Image API contributions require an orchestrator and runtime resolver.");
+  }
+  const generate = Object.freeze({
+    operationId: "images.generate",
+    handler: createImageGenerateHandler(deps)
+  });
+  const edit = Object.freeze({
+    operationId: "images.edit",
+    handler: createImageEditHandler(deps)
+  });
+  return Object.freeze({ generate, edit, all: Object.freeze([generate, edit]) });
+}
+
+// src/image-generation/openai-images/safeRemoteImageResolver.ts
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP } from "net";
+import { Agent, request } from "undici";
+function ipv4Number(value) {
+  const parts = value.split(".");
+  if (parts.length !== 4) return void 0;
+  let output = 0;
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part)) return void 0;
+    const octet = Number(part);
+    if (octet > 255 || String(octet) !== part) return void 0;
+    output = output * 256 + octet;
+  }
+  return output >>> 0;
+}
+function blockedIpv4(value) {
+  const address = ipv4Number(value);
+  if (address === void 0) return true;
+  const first = address >>> 24;
+  const second = address >>> 16 & 255;
+  if (first === 0 || first === 10 || first === 127) return true;
+  if (first === 100 && second >= 64 && second <= 127) return true;
+  if (first === 169 && second === 254) return true;
+  if (first === 172 && second >= 16 && second <= 31) return true;
+  if (first === 192 && second === 168) return true;
+  if (first === 192 && second === 0) return true;
+  if (first === 192 && second === 2) return true;
+  if (first === 198 && (second === 18 || second === 19 || second === 51)) return true;
+  if (first === 203 && second === 0) return true;
+  if (first >= 224) return true;
+  return false;
+}
+function ipv6Bytes(input) {
+  const zone = input.indexOf("%");
+  const value = (zone >= 0 ? input.slice(0, zone) : input).toLowerCase();
+  const halves = value.split("::");
+  if (halves.length > 2) return void 0;
+  const parseHalf = (half) => {
+    if (!half) return [];
+    const words2 = [];
+    for (const item of half.split(":")) {
+      if (item.includes(".")) {
+        const ipv4 = ipv4Number(item);
+        if (ipv4 === void 0) return void 0;
+        words2.push(ipv4 >>> 16 & 65535, ipv4 & 65535);
+      } else {
+        if (!/^[0-9a-f]{1,4}$/.test(item)) return void 0;
+        words2.push(Number.parseInt(item, 16));
+      }
+    }
+    return words2;
+  };
+  const left = parseHalf(halves[0]);
+  const right = parseHalf(halves[1] ?? "");
+  if (!left || !right) return void 0;
+  const missing = 8 - left.length - right.length;
+  if (halves.length === 1 && missing !== 0 || halves.length === 2 && missing < 1) return void 0;
+  const words = [...left, ...Array.from({ length: missing }, () => 0), ...right];
+  if (words.length !== 8) return void 0;
+  const bytes = new Uint8Array(16);
+  words.forEach((word, index) => {
+    bytes[index * 2] = word >>> 8;
+    bytes[index * 2 + 1] = word & 255;
+  });
+  return bytes;
+}
+function blockedIpv6(value) {
+  const bytes = ipv6Bytes(value);
+  if (!bytes) return true;
+  if (bytes.every((item) => item === 0)) return true;
+  if (bytes.slice(0, 15).every((item) => item === 0) && bytes[15] === 1) return true;
+  if ((bytes[0] & 254) === 252) return true;
+  if (bytes[0] === 254 && (bytes[1] & 192) === 128) return true;
+  if (bytes[0] === 255) return true;
+  const mapped = bytes.slice(0, 10).every((item) => item === 0) && bytes[10] === 255 && bytes[11] === 255;
+  if (mapped) return blockedIpv4(`${bytes[12]}.${bytes[13]}.${bytes[14]}.${bytes[15]}`);
+  const compatible = bytes.slice(0, 12).every((item) => item === 0);
+  if (compatible) return blockedIpv4(`${bytes[12]}.${bytes[13]}.${bytes[14]}.${bytes[15]}`);
+  return false;
+}
+function isBlockedRemoteAddress(address) {
+  const family = isIP(address);
+  return family === 4 ? blockedIpv4(address) : family === 6 ? blockedIpv6(address) : true;
+}
+function safeUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ImageGenerationError("invalid_image_request", { param: "image_url" });
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:" || url.username || url.password) {
+    throw new ImageGenerationError("invalid_image_request", { param: "image_url" });
+  }
+  return url;
+}
+function combinedSignal(parent, timeoutMs) {
+  return AbortSignal.any([parent, AbortSignal.timeout(timeoutMs)]);
+}
+function pinnedLookup(address) {
+  return ((_hostname, options, callback) => {
+    if (typeof options === "object" && options.all) {
+      callback(null, [{ address: address.address, family: address.family }]);
+      return;
+    }
+    callback(null, address.address, address.family);
+  });
+}
+async function defaultResolveAll(hostname, signal) {
+  const lookup = dnsLookup(hostname, { all: true, verbatim: true });
+  let abort;
+  try {
+    const results = await Promise.race([
+      lookup,
+      new Promise((_resolve, reject) => {
+        abort = () => reject(signal.reason);
+        if (signal.aborted) abort();
+        else signal.addEventListener("abort", abort, { once: true });
+      })
+    ]);
+    return results.filter((item) => item.family === 4 || item.family === 6);
+  } finally {
+    if (abort) signal.removeEventListener("abort", abort);
+  }
+}
+function headerBytes(headers) {
+  let total = 0;
+  for (const [name, value] of Object.entries(headers)) {
+    total += Buffer.byteLength(name);
+    for (const item of Array.isArray(value) ? value : [value ?? ""]) total += Buffer.byteLength(item);
+  }
+  return total;
+}
+function contentLength(value, maxBytes) {
+  if (value === void 0) return void 0;
+  if (Array.isArray(value) || !/^(0|[1-9]\d*)$/.test(value)) {
+    throw new ImageGenerationError("image_generation_failed");
+  }
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new ImageGenerationError("image_generation_failed");
+  if (parsed > maxBytes) throw new ImageGenerationError("image_too_large");
+  return parsed;
+}
+async function defaultRequestPinned(input) {
+  const dispatcher = new Agent({
+    maxHeaderSize: input.maxHeaderBytes,
+    connect: {
+      lookup: pinnedLookup(input.address),
+      timeout: input.connectTimeoutMs
+    }
+  });
+  try {
+    const response = await request(input.url, {
+      method: "GET",
+      dispatcher,
+      signal: input.signal,
+      maxRedirections: 0,
+      headersTimeout: input.connectTimeoutMs,
+      bodyTimeout: input.totalTimeoutMs,
+      headers: { accept: "image/png,image/jpeg,image/webp" }
+    });
+    return {
+      statusCode: response.statusCode,
+      headers: response.headers,
+      body: response.body,
+      close: () => dispatcher.close()
+    };
+  } catch (error) {
+    await dispatcher.close().catch(() => void 0);
+    throw error;
+  }
+}
+function createSafeRemoteImageResolver(deps = {}) {
+  const resolveAll = deps.resolveAll ?? defaultResolveAll;
+  const requestPinned = deps.requestPinned ?? defaultRequestPinned;
+  return {
+    async resolve(input) {
+      const totalSignal = combinedSignal(input.signal, input.limits.remoteTotalTimeoutMs);
+      let current = safeUrl(input.url);
+      try {
+        for (let redirects = 0; redirects <= input.limits.maxRedirects; redirects += 1) {
+          if (totalSignal.aborted) throw totalSignal.reason;
+          const literal = current.hostname.startsWith("[") && current.hostname.endsWith("]") ? current.hostname.slice(1, -1) : current.hostname;
+          const family = isIP(literal);
+          const answers = family ? [{ address: literal, family }] : await resolveAll(literal, totalSignal);
+          if (answers.length === 0 || answers.some((answer) => isBlockedRemoteAddress(answer.address))) {
+            throw new ImageGenerationError("invalid_image_request", { param: "image_url" });
+          }
+          const selected = answers[0];
+          const response = await requestPinned({
+            url: current,
+            address: selected,
+            signal: totalSignal,
+            connectTimeoutMs: input.limits.remoteConnectTimeoutMs,
+            totalTimeoutMs: input.limits.remoteTotalTimeoutMs,
+            maxHeaderBytes: input.limits.maxRemoteHeaderBytes
+          });
+          try {
+            if (headerBytes(response.headers) > input.limits.maxRemoteHeaderBytes) {
+              await response.body.dump();
+              throw new ImageGenerationError("image_too_large");
+            }
+            if ([301, 302, 303, 307, 308].includes(response.statusCode)) {
+              const location = response.headers.location;
+              await response.body.dump();
+              if (redirects >= input.limits.maxRedirects || typeof location !== "string") {
+                throw new ImageGenerationError("invalid_image_request", { param: "image_url" });
+              }
+              current = safeUrl(new URL(location, current).toString());
+              continue;
+            }
+            if (response.statusCode < 200 || response.statusCode >= 300) {
+              await response.body.dump();
+              throw new ImageGenerationError("image_generation_failed");
+            }
+            const declared = contentLength(response.headers["content-length"], input.limits.maxFileBytes);
+            return await input.materializer.materialize(response.body, declared, totalSignal);
+          } finally {
+            await response.close().catch(() => void 0);
+          }
+        }
+        throw new ImageGenerationError("invalid_image_request", { param: "image_url" });
+      } catch (error) {
+        if (error instanceof ImageGenerationError) throw error;
+        if (input.signal.aborted) {
+          throw new ImageGenerationError("request_cancelled", { cause: input.signal.reason });
+        }
+        if (totalSignal.aborted) throw new ImageGenerationError("image_generation_timeout");
+        throw new ImageGenerationError("image_generation_failed");
+      }
+    }
+  };
+}
+
+// src/image-generation/responses/ResponsesImageGenerationContribution.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/image-generation/responses/normalizeResponsesImageTool.ts
+var IMAGE_DECLARATION_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "action",
+  "size",
+  "quality",
+  "output_format",
+  "output_compression",
+  "background",
+  "partial_images"
+]);
+var CALL_ID_PATTERN = /^ig_[A-Za-z0-9_-]{16,128}$/;
+var RESPONSE_ID_PATTERN = /^resp_[A-Za-z0-9_-]{1,240}$/;
+var TOOL_IDENTITY_KEYS = /* @__PURE__ */ new Set(["declarationIndex", "type", "name"]);
+var MAX_SELECTED_TOOL_CALLS = 1024;
+var NORMALIZATION_RUNTIME = {
+  tenantId: "responses-image-inspection",
+  providerId: "responses-image-inspection",
+  defaultModel: "responses-image-model",
+  modelAliases: /* @__PURE__ */ new Map(),
+  limits: DEFAULT_IMAGE_API_LIMITS
+};
+function invalid5(param) {
+  throw new ImageGenerationError("invalid_image_request", { param });
+}
+function protocolFailure() {
+  throw new ImageGenerationError("upstream_protocol_changed");
+}
+function record(value, param) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) invalid5(param);
+  return value;
+}
+function parseSelectionPolicy(value) {
+  if (value === void 0 || value === "auto") return { kind: "auto" };
+  if (value === "required") return { kind: "required" };
+  if (value === "none") return { kind: "none" };
+  const choice = record(value, "tool_choice");
+  if (typeof choice.type !== "string" || !choice.type.trim() || choice.type.length > 128) {
+    invalid5("tool_choice");
+  }
+  if (choice.type === "image_generation") {
+    if (Object.keys(choice).some((key) => key !== "type")) invalid5("tool_choice");
+    return { kind: "forced_image" };
+  }
+  if (Object.keys(choice).some((key) => key !== "type" && key !== "name")) {
+    invalid5("tool_choice");
+  }
+  if (choice.name !== void 0 && (typeof choice.name !== "string" || !choice.name.trim() || choice.name.length > 128)) {
+    invalid5("tool_choice");
+  }
+  return {
+    kind: "forced_other",
+    toolType: choice.type,
+    ...choice.name !== void 0 ? { toolName: choice.name } : {}
+  };
+}
+function declaredOtherToolIdentity(value, declarationIndex) {
+  if (typeof value.type !== "string" || !value.type.trim() || value.type.length > 128) {
+    return void 0;
+  }
+  if (value.name !== void 0 && (typeof value.name !== "string" || !value.name.trim() || value.name.length > 128)) {
+    return void 0;
+  }
+  return Object.freeze({
+    declarationIndex,
+    type: value.type,
+    ...value.name !== void 0 ? { name: value.name } : {}
+  });
+}
+function sameToolIdentity(left, right) {
+  return left.declarationIndex === right.declarationIndex && left.type === right.type && left.name === right.name;
+}
+function forcedOtherMatches(policy, identity) {
+  return identity.type === policy.toolType && identity.name === policy.toolName;
+}
+function parsePreviousResponseId(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !RESPONSE_ID_PATTERN.test(value)) {
+    invalid5("previous_response_id");
+  }
+  return value;
+}
+function parseExplicitCallIds(value) {
+  if (value === void 0 || typeof value === "string") return Object.freeze([]);
+  if (!Array.isArray(value)) invalid5("input");
+  const ids = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const candidate = item;
+    if (candidate.type !== "image_generation_call") continue;
+    if (Object.keys(candidate).some((key) => key !== "type" && key !== "id")) invalid5("input");
+    if (typeof candidate.id !== "string" || !CALL_ID_PATTERN.test(candidate.id)) invalid5("input");
+    ids.push(candidate.id);
+  }
+  return Object.freeze(ids);
+}
+function parseDeclaration(value, stream) {
+  for (const key of Object.keys(value)) {
+    if (!IMAGE_DECLARATION_KEYS.has(key)) invalid5(`tools.${key}`);
+  }
+  const action = value.action === void 0 ? "auto" : value.action;
+  if (action !== "auto" && action !== "generate" && action !== "edit") invalid5("tools.action");
+  const options = normalizeImageOptions(
+    {
+      prompt: "responses image selection",
+      model: NORMALIZATION_RUNTIME.defaultModel,
+      n: 1,
+      moderation: "auto",
+      stream,
+      ...value.size !== void 0 ? { size: value.size } : {},
+      ...value.quality !== void 0 ? { quality: value.quality } : {},
+      ...value.output_format !== void 0 ? { output_format: value.output_format } : {},
+      ...value.output_compression !== void 0 ? { output_compression: value.output_compression } : {},
+      ...value.background !== void 0 ? { background: value.background } : {},
+      ...value.partial_images !== void 0 ? { partial_images: value.partial_images } : {}
+    },
+    NORMALIZATION_RUNTIME,
+    { action: "generate" }
+  );
+  return Object.freeze({
+    action,
+    quality: options.quality,
+    size: options.size,
+    background: options.background,
+    outputFormat: options.outputFormat,
+    ...options.outputCompression !== void 0 ? { outputCompression: options.outputCompression } : {},
+    partialImages: options.partialImages
+  });
+}
+function inspectResponsesImageRequest(input) {
+  if (!input || typeof input !== "object") invalid5();
+  const stream = input.stream === void 0 ? false : input.stream;
+  if (typeof stream !== "boolean") invalid5("stream");
+  const tools = input.tools === void 0 ? [] : input.tools;
+  if (!Array.isArray(tools)) invalid5("tools");
+  let imageToolIndex;
+  let declaration;
+  let otherToolCount = 0;
+  const otherTools = [];
+  for (let index = 0; index < tools.length; index += 1) {
+    const tool = tools[index];
+    if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+      otherToolCount += 1;
+      continue;
+    }
+    const candidate = tool;
+    if (candidate.type !== "image_generation") {
+      otherToolCount += 1;
+      const identity = declaredOtherToolIdentity(candidate, index);
+      if (identity) otherTools.push(identity);
+      continue;
+    }
+    if (imageToolIndex !== void 0) invalid5("tools");
+    imageToolIndex = index;
+    declaration = parseDeclaration(candidate, stream);
+  }
+  const selectionPolicy = parseSelectionPolicy(input.tool_choice);
+  if (selectionPolicy.kind === "forced_image" && imageToolIndex === void 0) {
+    invalid5("tool_choice");
+  }
+  if (selectionPolicy.kind === "forced_other" && !otherTools.some((identity) => forcedOtherMatches(selectionPolicy, identity))) {
+    invalid5("tool_choice");
+  }
+  const previousResponseId = parsePreviousResponseId(input.previous_response_id);
+  return Object.freeze({
+    declared: imageToolIndex !== void 0,
+    ...imageToolIndex !== void 0 ? { imageToolIndex } : {},
+    otherToolCount,
+    otherTools: Object.freeze(otherTools),
+    stream,
+    ...previousResponseId !== void 0 ? { previousResponseId } : {},
+    explicitCallIds: parseExplicitCallIds(input.input),
+    selectionPolicy,
+    ...declaration ? { options: declaration } : {}
+  });
+}
+function validateSelectedCall(call) {
+  if (!call || typeof call !== "object" || typeof call.prompt !== "string") protocolFailure();
+  if (!call.prompt.trim() || call.prompt.length > 32e3) protocolFailure();
+  if (Object.keys(call).some((key) => key !== "prompt")) {
+    protocolFailure();
+  }
+}
+function validateSelectedOtherTool(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) protocolFailure();
+  const candidate = value;
+  if (Object.keys(candidate).some((key) => !TOOL_IDENTITY_KEYS.has(key))) protocolFailure();
+  if (!Number.isSafeInteger(value.declarationIndex) || value.declarationIndex < 0 || typeof value.type !== "string" || !value.type.trim() || value.type.length > 128 || value.name !== void 0 && (typeof value.name !== "string" || !value.name.trim() || value.name.length > 128)) {
+    protocolFailure();
+  }
+}
+function validateResponsesImageSelection(admission, selection) {
+  if (!selection || typeof selection !== "object" || Array.isArray(selection) || !Array.isArray(selection.imageCalls) || !Array.isArray(selection.otherTools) || Object.keys(selection).some((key) => key !== "imageCalls" && key !== "otherToolCount" && key !== "otherTools")) {
+    protocolFailure();
+  }
+  if (!Number.isSafeInteger(selection.otherToolCount) || selection.otherToolCount < 0 || selection.otherToolCount !== selection.otherTools.length || selection.imageCalls.length + selection.otherToolCount > MAX_SELECTED_TOOL_CALLS) {
+    protocolFailure();
+  }
+  selection.imageCalls.forEach(validateSelectedCall);
+  selection.otherTools.forEach(validateSelectedOtherTool);
+  if (selection.imageCalls.length > 0 && !admission.declared) protocolFailure();
+  for (const selected of selection.otherTools) {
+    if (!admission.otherTools.some((declared) => sameToolIdentity(declared, selected))) {
+      protocolFailure();
+    }
+  }
+  const selectedAny = selection.imageCalls.length + selection.otherToolCount > 0;
+  switch (admission.selectionPolicy.kind) {
+    case "auto":
+      return;
+    case "required":
+      if (!selectedAny) protocolFailure();
+      return;
+    case "none":
+      if (selectedAny) protocolFailure();
+      return;
+    case "forced_image":
+      if (selection.imageCalls.length === 0 || selection.otherToolCount !== 0) protocolFailure();
+      return;
+    case "forced_other": {
+      const forcedOtherPolicy = admission.selectionPolicy;
+      if (selection.imageCalls.length > 0 || selection.otherTools.length === 0 || selection.otherTools.some(
+        (selected) => !forcedOtherMatches(forcedOtherPolicy, selected)
+      )) {
+        protocolFailure();
+      }
+      return;
+    }
+    default:
+      protocolFailure();
+  }
+}
+
+// src/image-generation/responses/ResponsesImageGenerationContribution.ts
+var CALL_ID_PATTERN2 = /^ig_[A-Za-z0-9_-]{16,128}$/;
+var RESPONSE_ID_PATTERN2 = /^resp_[A-Za-z0-9_-]{1,240}$/;
+function nonempty(value, max = 512) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= max;
+}
+function cancelled4(signal) {
+  throw new ImageGenerationError("request_cancelled", { cause: signal.reason });
+}
+function assertNotAborted(signal) {
+  if (signal.aborted) cancelled4(signal);
+}
+function stableError(error, signal) {
+  if (signal.aborted) return new ImageGenerationError("request_cancelled", { cause: signal.reason });
+  return normalizeImageGenerationError(error);
+}
+function assertRuntime(runtime) {
+  if (!runtime || typeof runtime !== "object") {
+    throw new ImageGenerationError("invalid_image_request");
+  }
+  if (!nonempty(runtime.tenantId) || !nonempty(runtime.requestId)) {
+    throw new ImageGenerationError("invalid_image_request");
+  }
+  if (!nonempty(runtime.providerId, 128)) {
+    throw new ImageGenerationError("invalid_image_request", { param: "provider" });
+  }
+  if (!nonempty(runtime.imageModel, 128)) {
+    throw new ImageGenerationError("invalid_image_request", { param: "model" });
+  }
+  if (!Number.isSafeInteger(runtime.referenceTtlMs) || runtime.referenceTtlMs <= 0 || !Number.isSafeInteger(runtime.maxOutputBytes) || runtime.maxOutputBytes <= 0 || !Number.isSafeInteger(runtime.maxTotalOutputBytes) || runtime.maxTotalOutputBytes < runtime.maxOutputBytes || !runtime.signal || typeof runtime.signal.aborted !== "boolean" || typeof runtime.signal.addEventListener !== "function" || typeof runtime.signal.removeEventListener !== "function") {
+    throw new ImageGenerationError("invalid_image_request");
+  }
+  for (const hint of [runtime.sessionKey, runtime.preferredAccountId, runtime.preferredAccountGroup]) {
+    if (hint !== void 0 && !nonempty(hint)) {
+      throw new ImageGenerationError("invalid_image_request");
+    }
+  }
+  if (runtime.boundAccountFallbackPolicy !== void 0 && runtime.boundAccountFallbackPolicy !== "strict" && runtime.boundAccountFallbackPolicy !== "pool") {
+    throw new ImageGenerationError("invalid_image_request");
+  }
+}
+function linkAbortSignal(signal) {
+  const controller = new AbortController();
+  const onAbort = () => {
+    if (!controller.signal.aborted) controller.abort(signal.reason);
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  if (signal.aborted) onAbort();
+  return {
+    controller,
+    removeListener: () => signal.removeEventListener("abort", onAbort)
+  };
+}
+function referenceFailure(status) {
+  throw new ImageGenerationError(
+    status === "expired" ? "image_reference_expired" : "image_reference_not_found"
+  );
+}
+function assertAssetAgreement(lease) {
+  const asset = lease.value.artifact;
+  const metadata = lease.metadata;
+  if (!asset || asset.independentlyDecodable !== true || asset.mimeType !== metadata.mimeType || asset.byteLength !== metadata.byteLength || asset.width !== metadata.width || asset.height !== metadata.height || asset.artifactId.length === 0) {
+    throw new ImageGenerationError("upstream_protocol_changed");
+  }
+  return asset;
+}
+async function releaseQuietly(leases) {
+  for (const lease of [...leases].reverse()) {
+    try {
+      await lease.release();
+    } catch {
+    }
+  }
+}
+async function createScope(deps, now, input) {
+  assertRuntime(input.runtime);
+  const { admission, runtime } = input;
+  const linked = linkAbortSignal(runtime.signal);
+  const responseLeases = [];
+  const stateLeases = [];
+  const imageLeases = [];
+  const callIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addCallId = (callId) => {
+    if (!seen.has(callId)) {
+      seen.add(callId);
+      callIds.push(callId);
+    }
+  };
+  try {
+    assertNotAborted(linked.controller.signal);
+    if (!admission || typeof admission !== "object") {
+      throw new ImageGenerationError("invalid_image_request");
+    }
+    if (admission.previousResponseId !== void 0) {
+      if (input.authorizedPreviousResponseId !== admission.previousResponseId) {
+        throw new ImageGenerationError("image_reference_not_found");
+      }
+    } else if (input.authorizedPreviousResponseId !== void 0) {
+      throw new ImageGenerationError("invalid_image_request", { param: "previous_response_id" });
+    }
+    if (input.authorizedPreviousResponseKnownEmpty !== void 0 && (typeof input.authorizedPreviousResponseKnownEmpty !== "boolean" || input.authorizedPreviousResponseId === void 0)) {
+      throw new ImageGenerationError("invalid_image_request", { param: "previous_response_id" });
+    }
+    admission.explicitCallIds.forEach(addCallId);
+    if (input.authorizedPreviousResponseId !== void 0) {
+      const response = await deps.stateStore.resolveResponse(
+        runtime.tenantId,
+        input.authorizedPreviousResponseId
+      );
+      if (response.status === "found") responseLeases.push(response.lease);
+      assertNotAborted(linked.controller.signal);
+      if (response.status === "expired") referenceFailure(response.status);
+      if (response.status === "not_found" && input.authorizedPreviousResponseKnownEmpty !== true) {
+        referenceFailure(response.status);
+      }
+      if (response.status === "found") response.lease.callIds.forEach(addCallId);
+    }
+    const resolvedInputs = [];
+    for (const callId of callIds) {
+      assertNotAborted(linked.controller.signal);
+      const state = await deps.stateStore.resolveCall(runtime.tenantId, callId);
+      if (state.status === "found") stateLeases.push(state.lease);
+      assertNotAborted(linked.controller.signal);
+      if (state.status !== "found") referenceFailure(state.status);
+      const image = await deps.referenceStore.resolve(
+        runtime.tenantId,
+        state.lease.binding.referenceId
+      );
+      if (image.status === "found") imageLeases.push(image.lease);
+      assertNotAborted(linked.controller.signal);
+      if (image.status !== "found") referenceFailure(image.status);
+      if (image.lease.metadata.referenceId !== state.lease.binding.referenceId) {
+        throw new ImageGenerationError("upstream_protocol_changed");
+      }
+      resolvedInputs.push({
+        binding: state.lease.binding,
+        asset: assertAssetAgreement(image.lease),
+        stateLease: state.lease,
+        imageLease: image.lease
+      });
+    }
+    assertNotAborted(linked.controller.signal);
+    return new RequestScope(
+      deps,
+      now,
+      input,
+      resolvedInputs,
+      responseLeases,
+      linked.controller,
+      linked.removeListener
+    );
+  } catch (error) {
+    await releaseQuietly([...imageLeases, ...stateLeases, ...responseLeases]);
+    linked.removeListener();
+    throw stableError(error, linked.controller.signal);
+  }
+}
+var RequestScope = class {
+  #deps;
+  #now;
+  #admission;
+  #runtime;
+  #resolvedInputs;
+  #responseLeases;
+  #pendingBindings = [];
+  #newReferenceIds = /* @__PURE__ */ new Set();
+  #newReferenceLeases = [];
+  #allocatedCallIds = /* @__PURE__ */ new Set();
+  #scopeController;
+  #removeRuntimeAbortListener;
+  #usedBytes = 0;
+  #lastOutputIndex = -1;
+  #lastSequenceNumber = -1;
+  #state = "open";
+  #disposeRequested = false;
+  #executionDone;
+  #resolveExecutionDone;
+  #activeExecutionIterator;
+  #activeIteratorClosePromise;
+  #commitResponseId;
+  #commitPromise;
+  #committedResponseId;
+  #disposePromise;
+  constructor(deps, now, input, resolvedInputs, responseLeases, scopeController, removeRuntimeAbortListener) {
+    this.#deps = deps;
+    this.#now = now;
+    this.#admission = input.admission;
+    this.#runtime = input.runtime;
+    this.#resolvedInputs = Object.freeze([...resolvedInputs]);
+    this.#responseLeases = Object.freeze([...responseLeases]);
+    this.#scopeController = scopeController;
+    this.#removeRuntimeAbortListener = removeRuntimeAbortListener;
+    for (const item of resolvedInputs) this.#allocatedCallIds.add(item.binding.callId);
+  }
+  executeSelectedCall(call, allocator) {
+    const generator = this.#executeSelectedCall(call, allocator);
+    let tracked;
+    const clearIfCurrent = () => {
+      if (this.#activeExecutionIterator === tracked) {
+        this.#activeExecutionIterator = void 0;
+        this.#activeIteratorClosePromise = void 0;
+      }
+    };
+    tracked = {
+      next: async () => {
+        if (this.#activeExecutionIterator === void 0 || this.#activeExecutionIterator === tracked) {
+          this.#activeExecutionIterator = tracked;
+        }
+        const result = await generator.next();
+        if (result.done) clearIfCurrent();
+        return result;
+      },
+      return: async () => {
+        try {
+          return await generator.return(void 0);
+        } finally {
+          clearIfCurrent();
+        }
+      },
+      throw: async (error) => {
+        try {
+          return await generator.throw(error);
+        } finally {
+          clearIfCurrent();
+        }
+      }
+    };
+    return Object.freeze({
+      [Symbol.asyncIterator]: () => tracked
+    });
+  }
+  async *#executeSelectedCall(call, allocator) {
+    let callId;
+    let outputIndex;
+    let started = false;
+    let providerIterator;
+    try {
+      this.#beginExecution();
+      started = true;
+      if (!this.#admission.declared || !this.#admission.options) {
+        throw new ImageGenerationError("upstream_protocol_changed");
+      }
+      if (!call || typeof call !== "object" || !nonempty(call.prompt, 32e3)) {
+        throw new ImageGenerationError("upstream_protocol_changed");
+      }
+      if (!allocator || typeof allocator.reserveOutputIndex !== "function" || typeof allocator.nextSequenceNumber !== "function") {
+        throw new ImageGenerationError("image_generation_failed");
+      }
+      assertNotAborted(this.#scopeController.signal);
+      const candidateCallId = (this.#deps.createCallId ?? (() => `ig_${randomUUID4().replaceAll("-", "")}`))();
+      if (!CALL_ID_PATTERN2.test(candidateCallId) || this.#allocatedCallIds.has(candidateCallId)) {
+        throw new ImageGenerationError("image_generation_failed");
+      }
+      callId = candidateCallId;
+      this.#allocatedCallIds.add(callId);
+      outputIndex = allocator.reserveOutputIndex();
+      if (!Number.isSafeInteger(outputIndex) || outputIndex < 0 || outputIndex <= this.#lastOutputIndex) {
+        throw new ImageGenerationError("image_generation_failed");
+      }
+      this.#lastOutputIndex = outputIndex;
+      const request2 = this.#buildRequest(call);
+      const context = {
+        requestId: this.#runtime.requestId,
+        tenantId: this.#runtime.tenantId,
+        signal: this.#scopeController.signal,
+        ...this.#runtime.sessionKey !== void 0 ? { sessionKey: this.#runtime.sessionKey } : {},
+        ...this.#runtime.preferredAccountId !== void 0 ? { preferredAccountId: this.#runtime.preferredAccountId } : {},
+        ...this.#runtime.preferredAccountGroup !== void 0 ? { preferredAccountGroup: this.#runtime.preferredAccountGroup } : {},
+        ...this.#runtime.boundAccountFallbackPolicy !== void 0 ? { boundAccountFallbackPolicy: this.#runtime.boundAccountFallbackPolicy } : {}
+      };
+      const iterator = this.#deps.orchestrator.run(request2, context, {
+        providerId: this.#runtime.providerId,
+        retention: { enabled: true, ttlMs: this.#runtime.referenceTtlMs },
+        requireResponsesTool: true
+      })[Symbol.asyncIterator]();
+      providerIterator = iterator;
+      while (true) {
+        const next = await iterator.next();
+        if (!next.done && next.value.type === "completed" && next.value.images.length === 1 && next.value.references?.length === 1) {
+          this.#newReferenceIds.add(next.value.references[0].referenceId);
+        }
+        if (next.done) throw new ImageGenerationError("upstream_protocol_changed");
+        const event = next.value;
+        assertNotAborted(this.#scopeController.signal);
+        if (event.type === "accepted") {
+          yield Object.freeze({
+            kind: "started",
+            outputIndex,
+            item: Object.freeze({
+              id: callId,
+              type: "image_generation_call",
+              status: "in_progress"
+            })
+          });
+          continue;
+        }
+        if (event.type === "partial_image") {
+          const sequence = allocator.nextSequenceNumber();
+          if (!Number.isSafeInteger(sequence) || sequence < 0 || sequence <= this.#lastSequenceNumber) {
+            throw new ImageGenerationError("image_generation_failed");
+          }
+          this.#lastSequenceNumber = sequence;
+          const partial = await this.#readBase64(event.image.artifact);
+          assertNotAborted(this.#scopeController.signal);
+          yield Object.freeze({
+            type: "response.image_generation_call.partial_image",
+            output_index: outputIndex,
+            item_id: callId,
+            sequence_number: sequence,
+            partial_image_index: event.partialImageIndex,
+            partial_image_b64: partial
+          });
+          continue;
+        }
+        if (event.type === "failed") {
+          yield Object.freeze({
+            kind: "failed",
+            outputIndex,
+            callId,
+            error: serializeImageGenerationError(imageGenerationErrorFromPublic(event.error))
+          });
+          return;
+        }
+        if (event.images.length !== 1 || !event.references || event.references.length !== 1) {
+          throw new ImageGenerationError("upstream_protocol_changed");
+        }
+        const image = event.images[0];
+        const reference = event.references[0];
+        const retained = await this.#deps.referenceStore.resolve(
+          this.#runtime.tenantId,
+          reference.referenceId
+        );
+        if (retained.status !== "found") throw new ImageGenerationError("upstream_protocol_changed");
+        this.#newReferenceLeases.push(retained.lease);
+        const retainedAsset = assertAssetAgreement(retained.lease);
+        if (retained.lease.metadata.referenceId !== reference.referenceId || retainedAsset.artifactId !== image.artifact.artifactId || reference.mimeType !== image.artifact.mimeType || reference.byteLength !== image.artifact.byteLength || reference.width !== image.artifact.width || reference.height !== image.artifact.height) {
+          throw new ImageGenerationError("upstream_protocol_changed");
+        }
+        const result = await this.#readBase64(image.artifact);
+        assertNotAborted(this.#scopeController.signal);
+        const binding = Object.freeze({
+          callId,
+          referenceId: reference.referenceId,
+          expiresAt: reference.expiresAt
+        });
+        this.#pendingBindings.push(binding);
+        yield Object.freeze({
+          kind: "completed",
+          outputIndex,
+          item: Object.freeze({
+            id: callId,
+            type: "image_generation_call",
+            status: "completed",
+            result,
+            ...image.revisedPrompt !== void 0 ? { revised_prompt: image.revisedPrompt } : {}
+          })
+        });
+        return;
+      }
+    } catch (error) {
+      const safe = stableError(error, this.#scopeController.signal);
+      yield Object.freeze({
+        kind: "failed",
+        ...outputIndex !== void 0 ? { outputIndex } : {},
+        ...callId !== void 0 ? { callId } : {},
+        error: serializeImageGenerationError(safe)
+      });
+    } finally {
+      try {
+        await providerIterator?.return?.();
+      } catch {
+      }
+      if (started) this.#finishExecution();
+    }
+  }
+  commit(responseId) {
+    if (!RESPONSE_ID_PATTERN2.test(responseId)) return this.#commitFailure();
+    if (this.#state === "committing") {
+      return this.#commitResponseId === responseId ? this.#commitPromise : this.#commitFailure();
+    }
+    if (this.#state === "committed") {
+      return this.#committedResponseId === responseId ? this.#commitPromise ?? Promise.resolve() : this.#commitFailure();
+    }
+    if (this.#state !== "open" || this.#disposeRequested) return this.#commitFailure();
+    try {
+      assertNotAborted(this.#scopeController.signal);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    this.#state = "committing";
+    this.#commitResponseId = responseId;
+    this.#commitPromise = Promise.resolve().then(() => this.#performCommit(responseId));
+    return this.#commitPromise;
+  }
+  async #performCommit(responseId) {
+    const bindings = [...this.#resolvedInputs.map((item) => item.binding), ...this.#pendingBindings];
+    try {
+      const evicted = await this.#deps.stateStore.commit({
+        tenantId: this.#runtime.tenantId,
+        responseId,
+        bindings,
+        responseExpiresAt: this.#now() + this.#runtime.referenceTtlMs
+      });
+      this.#committedResponseId = responseId;
+      this.#state = "committed";
+      for (const binding of evicted) {
+        try {
+          await this.#deps.referenceStore.delete(this.#runtime.tenantId, binding.referenceId);
+        } catch {
+        }
+      }
+    } catch (error) {
+      if (this.#state === "committing") this.#state = "open";
+      this.#commitResponseId = void 0;
+      throw stableError(error, this.#scopeController.signal);
+    }
+  }
+  dispose() {
+    if (this.#disposePromise) return this.#disposePromise;
+    this.#disposeRequested = true;
+    this.#disposePromise = this.#performDispose();
+    return this.#disposePromise;
+  }
+  async waitForIdle() {
+    const operations = [this.#executionDone, this.#commitPromise].filter((value) => value !== void 0);
+    await Promise.allSettled(operations);
+  }
+  #buildRequest(call) {
+    const options = this.#admission.options;
+    const common = {
+      model: this.#runtime.imageModel,
+      prompt: call.prompt,
+      n: 1,
+      quality: options.quality,
+      size: options.size,
+      background: options.background,
+      outputFormat: options.outputFormat,
+      ...options.outputCompression !== void 0 ? { outputCompression: options.outputCompression } : {},
+      moderation: "auto",
+      stream: options.partialImages > 0,
+      partialImages: options.partialImages
+    };
+    const action = options.action === "auto" ? this.#resolvedInputs.length > 0 ? "edit" : "generate" : options.action;
+    if (action === "generate") return { action, ...common };
+    if (this.#resolvedInputs.length === 0) {
+      throw new ImageGenerationError("invalid_image_request", { param: "input" });
+    }
+    return { action, ...common, images: this.#resolvedInputs.map((item) => item.asset) };
+  }
+  async #readBase64(asset) {
+    assertNotAborted(this.#scopeController.signal);
+    if (!Number.isSafeInteger(asset.byteLength) || asset.byteLength <= 0 || asset.byteLength > this.#runtime.maxOutputBytes || this.#usedBytes > this.#runtime.maxTotalOutputBytes - asset.byteLength) {
+      throw new ImageGenerationError("image_too_large");
+    }
+    this.#usedBytes += asset.byteLength;
+    let bytes;
+    try {
+      bytes = await readImageAssetBytes(
+        asset,
+        this.#runtime.maxOutputBytes,
+        this.#scopeController.signal
+      );
+    } catch (error) {
+      if (this.#scopeController.signal.aborted) cancelled4(this.#scopeController.signal);
+      if (error instanceof RangeError) {
+        throw new ImageGenerationError("upstream_protocol_changed");
+      }
+      throw error;
+    }
+    assertNotAborted(this.#scopeController.signal);
+    return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString("base64");
+  }
+  #beginExecution() {
+    if (this.#state !== "open" || this.#disposeRequested) {
+      throw new ImageGenerationError("invalid_image_request");
+    }
+    this.#state = "executing";
+    this.#executionDone = new Promise((resolve2) => {
+      this.#resolveExecutionDone = resolve2;
+    });
+  }
+  #finishExecution() {
+    if (this.#state === "executing") this.#state = "open";
+    this.#resolveExecutionDone?.();
+    this.#resolveExecutionDone = void 0;
+  }
+  #commitFailure() {
+    return Promise.reject(new ImageGenerationError("image_generation_failed"));
+  }
+  #closeActiveIterator() {
+    if (this.#activeIteratorClosePromise) return this.#activeIteratorClosePromise;
+    const iterator = this.#activeExecutionIterator;
+    if (!iterator?.return) return Promise.resolve();
+    this.#activeIteratorClosePromise = Promise.resolve(iterator.return()).then(
+      () => void 0,
+      () => void 0
+    );
+    return this.#activeIteratorClosePromise;
+  }
+  async #performDispose() {
+    if (this.#state === "executing" && !this.#scopeController.signal.aborted) {
+      this.#scopeController.abort(new Error("Responses image request scope disposed."));
+    }
+    const executionDone = this.#executionDone;
+    await Promise.allSettled([
+      this.#closeActiveIterator(),
+      ...executionDone ? [executionDone] : []
+    ]);
+    if (this.#commitPromise) {
+      await this.#commitPromise.catch(() => void 0);
+    }
+    if (this.#committedResponseId === void 0) {
+      for (const referenceId of this.#newReferenceIds) {
+        try {
+          await this.#deps.referenceStore.delete(this.#runtime.tenantId, referenceId);
+        } catch {
+        }
+      }
+    }
+    await releaseQuietly([
+      ...this.#newReferenceLeases,
+      ...this.#resolvedInputs.map((item) => item.imageLease),
+      ...this.#resolvedInputs.map((item) => item.stateLease),
+      ...this.#responseLeases
+    ]);
+    if (!this.#scopeController.signal.aborted) {
+      this.#scopeController.abort(new Error("Responses image request scope disposed."));
+    }
+    this.#removeRuntimeAbortListener();
+    this.#state = "disposed";
+  }
+};
+function createResponsesImageGenerationContribution(deps) {
+  if (!deps || typeof deps !== "object" || !deps.orchestrator || !deps.stateStore || !deps.referenceStore || deps.createCallId !== void 0 && typeof deps.createCallId !== "function" || deps.now !== void 0 && typeof deps.now !== "function") {
+    throw new TypeError("Responses image generation requires orchestrator and state/reference stores.");
+  }
+  const now = deps.now ?? Date.now;
+  return Object.freeze({
+    toolType: "image_generation",
+    inspectRequest: inspectResponsesImageRequest,
+    validateSelection: validateResponsesImageSelection,
+    createRequestScope: (input) => createScope(deps, now, input)
+  });
+}
+
+// src/image-generation/responses/ResponsesImageStateStore.ts
+var CALL_ID_PATTERN3 = /^ig_[A-Za-z0-9_-]{16,128}$/;
+var RESPONSE_ID_PATTERN3 = /^resp_[A-Za-z0-9_-]{1,240}$/;
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) throw new RangeError(`${name} must be positive.`);
+  return value;
+}
+function safeTenant(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= 512;
+}
+function sameBinding(a, b) {
+  return a.callId === b.callId && a.referenceId === b.referenceId && a.expiresAt === b.expiresAt;
+}
+function sameIds(a, b) {
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+var InMemoryResponsesImageStateStore = class {
+  #calls = /* @__PURE__ */ new Map();
+  #responses = /* @__PURE__ */ new Map();
+  #tombstones = /* @__PURE__ */ new Map();
+  #maxCalls;
+  #maxResponses;
+  #maxTombstones;
+  #tombstoneTtlMs;
+  #now;
+  constructor(options = {}) {
+    this.#maxCalls = positiveInteger(options.maxCalls ?? 1e4, "maxCalls");
+    this.#maxResponses = positiveInteger(options.maxResponses ?? 1e4, "maxResponses");
+    this.#maxTombstones = positiveInteger(options.maxTombstones ?? 2e3, "maxTombstones");
+    this.#tombstoneTtlMs = positiveInteger(
+      options.tombstoneTtlMs ?? 60 * 6e4,
+      "tombstoneTtlMs"
+    );
+    this.#now = options.now ?? Date.now;
+  }
+  async commit(input) {
+    const now = this.#now();
+    this.#pruneTombstones(now);
+    this.#assertCommit(input, now);
+    const unique = new Set(input.bindings.map((binding) => binding.callId));
+    if (unique.size !== input.bindings.length) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    for (const binding of input.bindings) {
+      const current = this.#calls.get(binding.callId);
+      if (current && (current.deleted || current.tenantId !== input.tenantId || !sameBinding(current.binding, binding))) {
+        throw new ImageGenerationError("image_generation_failed");
+      }
+    }
+    const currentResponse = this.#responses.get(input.responseId);
+    const callIds = Object.freeze(input.bindings.map((binding) => binding.callId));
+    if (currentResponse && (currentResponse.deleted || currentResponse.tenantId !== input.tenantId || currentResponse.expiresAt !== input.responseExpiresAt || !sameIds(currentResponse.callIds, callIds))) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    const protectedCalls = new Set(callIds);
+    const additionalCalls = input.bindings.filter((binding) => !this.#calls.has(binding.callId)).length;
+    const unleasedCalls = [...this.#calls.entries()].filter(
+      ([id, entry]) => entry.activeLeases === 0 && !protectedCalls.has(id)
+    );
+    const evictableCalls = [
+      ...unleasedCalls.filter(([, entry]) => entry.binding.expiresAt <= now),
+      ...unleasedCalls.filter(([, entry]) => entry.binding.expiresAt > now)
+    ];
+    const callsToRemove = Math.max(0, this.#calls.size + additionalCalls - this.#maxCalls);
+    if (evictableCalls.length < callsToRemove) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    const additionalResponse = currentResponse ? 0 : 1;
+    const unleasedResponses = [...this.#responses.entries()].filter(
+      ([id, entry]) => entry.activeLeases === 0 && id !== input.responseId
+    );
+    const evictableResponses = [
+      ...unleasedResponses.filter(([, entry]) => entry.expiresAt <= now),
+      ...unleasedResponses.filter(([, entry]) => entry.expiresAt > now)
+    ];
+    const responsesToRemove = Math.max(
+      0,
+      this.#responses.size + additionalResponse - this.#maxResponses
+    );
+    if (evictableResponses.length < responsesToRemove) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    const evicted = [];
+    for (const [id, entry] of evictableCalls.slice(0, callsToRemove)) {
+      if (entry.binding.expiresAt <= now) {
+        this.#rememberTombstone("call", entry.tenantId, id, now);
+      }
+      this.#calls.delete(id);
+      evicted.push(entry.binding);
+    }
+    for (const [id, entry] of evictableResponses.slice(0, responsesToRemove)) {
+      if (entry.expiresAt <= now) {
+        this.#rememberTombstone("response", entry.tenantId, id, now);
+      }
+      this.#responses.delete(id);
+    }
+    for (const binding of input.bindings) {
+      const current = this.#calls.get(binding.callId);
+      if (current) {
+        this.#touch(this.#calls, binding.callId, current);
+      } else {
+        this.#calls.set(binding.callId, {
+          tenantId: input.tenantId,
+          binding: Object.freeze({ ...binding }),
+          activeLeases: 0,
+          deleted: false
+        });
+      }
+    }
+    if (currentResponse) {
+      this.#touch(this.#responses, input.responseId, currentResponse);
+    } else {
+      this.#responses.set(input.responseId, {
+        tenantId: input.tenantId,
+        responseId: input.responseId,
+        callIds,
+        expiresAt: input.responseExpiresAt,
+        activeLeases: 0,
+        deleted: false
+      });
+    }
+    return Object.freeze(evicted);
+  }
+  async resolveCall(tenantId, callId) {
+    if (!safeTenant(tenantId) || !CALL_ID_PATTERN3.test(callId)) return { status: "not_found" };
+    const now = this.#now();
+    this.#pruneTombstones(now);
+    const entry = this.#calls.get(callId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) {
+      return this.#hasTombstone("call", tenantId, callId) ? { status: "expired" } : { status: "not_found" };
+    }
+    if (entry.binding.expiresAt <= now) {
+      this.#rememberTombstone("call", tenantId, callId, now);
+      return { status: "expired" };
+    }
+    entry.activeLeases += 1;
+    this.#touch(this.#calls, callId, entry);
+    let released = false;
+    return {
+      status: "found",
+      lease: {
+        binding: entry.binding,
+        async release() {
+          if (released) return;
+          released = true;
+          entry.activeLeases = Math.max(0, entry.activeLeases - 1);
+        }
+      }
+    };
+  }
+  async resolveResponse(tenantId, responseId) {
+    if (!safeTenant(tenantId) || !RESPONSE_ID_PATTERN3.test(responseId)) return { status: "not_found" };
+    const now = this.#now();
+    this.#pruneTombstones(now);
+    const entry = this.#responses.get(responseId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) {
+      return this.#hasTombstone("response", tenantId, responseId) ? { status: "expired" } : { status: "not_found" };
+    }
+    if (entry.expiresAt <= now) {
+      this.#rememberTombstone("response", tenantId, responseId, now);
+      return { status: "expired" };
+    }
+    entry.activeLeases += 1;
+    this.#touch(this.#responses, responseId, entry);
+    let released = false;
+    return {
+      status: "found",
+      lease: {
+        responseId,
+        callIds: entry.callIds,
+        expiresAt: entry.expiresAt,
+        async release() {
+          if (released) return;
+          released = true;
+          entry.activeLeases = Math.max(0, entry.activeLeases - 1);
+        }
+      }
+    };
+  }
+  async deleteCall(tenantId, callId) {
+    const entry = this.#calls.get(callId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) return void 0;
+    entry.deleted = true;
+    if (entry.activeLeases === 0) this.#calls.delete(callId);
+    return entry.binding;
+  }
+  async deleteResponse(tenantId, responseId) {
+    const entry = this.#responses.get(responseId);
+    if (!entry || entry.tenantId !== tenantId || entry.deleted) return false;
+    entry.deleted = true;
+    if (entry.activeLeases === 0) this.#responses.delete(responseId);
+    return true;
+  }
+  async cleanup(now = this.#now()) {
+    if (!Number.isFinite(now)) throw new RangeError("cleanup time must be finite.");
+    this.#pruneTombstones(now);
+    const removed = [];
+    for (const [callId, entry] of this.#calls) {
+      const expired = entry.binding.expiresAt <= now;
+      if (expired) this.#rememberTombstone("call", entry.tenantId, callId, now);
+      if ((expired || entry.deleted) && entry.activeLeases === 0) {
+        this.#calls.delete(callId);
+        removed.push(entry.binding);
+      }
+    }
+    for (const [responseId, entry] of this.#responses) {
+      const expired = entry.expiresAt <= now;
+      if (expired) this.#rememberTombstone("response", entry.tenantId, responseId, now);
+      if ((expired || entry.deleted) && entry.activeLeases === 0) {
+        this.#responses.delete(responseId);
+      }
+    }
+    return Object.freeze(removed);
+  }
+  #assertCommit(input, now) {
+    if (!safeTenant(input.tenantId)) throw new ImageGenerationError("image_generation_failed");
+    if (!RESPONSE_ID_PATTERN3.test(input.responseId)) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    if (!Number.isSafeInteger(input.responseExpiresAt) || input.responseExpiresAt <= now) {
+      throw new ImageGenerationError("image_generation_failed");
+    }
+    if (!Array.isArray(input.bindings)) throw new ImageGenerationError("image_generation_failed");
+    for (const binding of input.bindings) {
+      if (!binding || !CALL_ID_PATTERN3.test(binding.callId) || typeof binding.referenceId !== "string" || binding.referenceId.length === 0 || !Number.isSafeInteger(binding.expiresAt) || binding.expiresAt <= now) {
+        throw new ImageGenerationError("image_generation_failed");
+      }
+    }
+  }
+  #rememberTombstone(kind, tenantId, id, now) {
+    const key = `${kind}\0${tenantId}\0${id}`;
+    this.#tombstones.delete(key);
+    this.#tombstones.set(key, now + this.#tombstoneTtlMs);
+    while (this.#tombstones.size > this.#maxTombstones) {
+      const oldest = this.#tombstones.keys().next().value;
+      if (oldest === void 0) break;
+      this.#tombstones.delete(oldest);
+    }
+  }
+  #hasTombstone(kind, tenantId, id) {
+    return this.#tombstones.has(`${kind}\0${tenantId}\0${id}`);
+  }
+  #pruneTombstones(now) {
+    for (const [key, expiresAt] of this.#tombstones) {
+      if (expiresAt <= now) this.#tombstones.delete(key);
+    }
+  }
+  #touch(map, key, value) {
+    map.delete(key);
+    map.set(key, value);
+  }
+};
+
+export {
+  resolveImageCapabilities,
+  ImageGenerationError,
+  isImageGenerationError,
+  serializeImageGenerationError,
+  normalizeImageGenerationError,
+  imageGenerationErrorFromPublic,
+  InMemoryImageAsset,
+  readImageAssetBytes,
+  InMemoryImageReferenceStore,
+  emitImageTelemetry,
+  ImageOrchestrator,
+  ImageProviderRegistry,
+  IMAGE_REQUEST_DIRECTORY_MARKER_NAME,
+  IMAGE_REQUEST_DIRECTORY_MARKER_CONTENT,
+  ImageRequestResourceScope,
+  createImageRequestResourceScope,
+  DEFAULT_IMAGE_API_LIMITS,
+  assertFiniteImageApiLimits,
+  createImageApiContributions,
+  createSafeRemoteImageResolver,
+  inspectResponsesImageRequest,
+  validateResponsesImageSelection,
+  createResponsesImageGenerationContribution,
+  InMemoryResponsesImageStateStore
+};