Files
universal-web-api/app/services/arena_gpt_image_command.py
T
2026-11-02 22:54:14 +08:00

892 lines
34 KiB
Python

"""Dedicated Arena blind-test runner for GPT Image 2 C2PA detection."""
from __future__ import annotations
import os
import random
import time
from pathlib import Path
from typing import Any
from urllib.parse import urlsplit
from app.services.arena_image_generation import (
image_signatures as _image_signatures,
read_image_bytes as _read_image_bytes,
same_image as _same_image,
)
from app.core.driver import as_element, driver_for_tab
GPT_IMAGE_MARKERS = (
b"gpt-image",
b"OpenAI Media Service API",
b"OpenAI OpCo, LLC",
)
ARENA_RESULT_IMAGE_SELECTOR = (
"img.transition-opacity.duration-500.opacity-100.aspect-square.object-cover"
)
ARENA_AGENT_PAGE_PATH = "/agent"
def inspect_gpt_image2_png(payload: bytes) -> dict[str, Any]:
"""Return strong GPT Image 2 evidence found in a PNG C2PA caBX chunk."""
data = bytes(payload or b"")
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
return {"matched": False, "reason": "not_png", "markers": []}
offset = 8
cabx_chunks: list[bytes] = []
while offset + 12 <= len(data):
length = int.from_bytes(data[offset : offset + 4], "big")
chunk_type = data[offset + 4 : offset + 8]
chunk_end = offset + 12 + length
if chunk_end > len(data):
return {"matched": False, "reason": "invalid_png", "markers": []}
if chunk_type == b"caBX":
cabx_chunks.append(data[offset + 8 : offset + 8 + length])
offset = chunk_end
if chunk_type == b"IEND":
break
if not cabx_chunks:
return {"matched": False, "reason": "c2pa_missing", "markers": []}
manifest = b"".join(cabx_chunks)
marker_hits = [marker.decode("ascii") for marker in GPT_IMAGE_MARKERS if marker in manifest]
# CBOR text values use one-byte length prefixes here: i=9 for gpt-image,
# c=3 for 2.0. Requiring the adjacent fields prevents a stray version
# elsewhere in the signed manifest from producing a false positive.
has_model = b"dnameigpt-imagegversionc2.0" in manifest
has_openai_claim = b"OpenAI Media Service API" in manifest
matched = has_model and has_openai_claim
return {
"matched": matched,
"reason": "gpt_image_2_c2pa" if matched else "c2pa_not_gpt_image_2",
"markers": marker_hits,
"caBX_bytes": len(manifest),
}
def _value(values: dict[str, Any], key: str, default: Any = "") -> Any:
value = values.get(key, default)
return default if value is None else value
def _sleep(ctx: dict[str, Any], seconds: float, step: float = 0.2) -> None:
deadline = time.time() + max(0.0, float(seconds))
while time.time() < deadline:
ctx["raise_if_cancelled"]()
ctx["raise_if_command_loop_cancelled"]()
agent_guard = ctx.get("_arena_agent_guard")
if agent_guard and agent_guard():
raise RuntimeError("arena_agent_redirected")
ctx["reset_timeout"]()
time.sleep(min(step, max(0.0, deadline - time.time())))
def _current_url(tab: Any) -> str:
try:
return str(driver_for_tab(tab).run_js("return location.href") or "").strip()
except Exception:
return str(getattr(tab, "url", "") or "").strip()
def _is_agent_page_url(url: str) -> bool:
"""Return whether Arena has landed on its agent page, which is abnormal for this runner."""
try:
parsed = urlsplit(str(url or "").strip())
return (
parsed.scheme.lower() == "https"
and parsed.netloc.lower() == "arena.ai"
and parsed.path.rstrip("/") == ARENA_AGENT_PAGE_PATH
)
except Exception:
return False
def _redirect_if_agent_page(ctx: dict[str, Any], redirect_url: str) -> bool:
"""Redirect an unexpected /agent page and report whether the guard fired."""
tab = ctx["tab"]
current_url = _current_url(tab)
if not _is_agent_page_url(current_url):
return False
logger = ctx["logger"]
logger.warning(
f"[GPT-IMAGE-2] unexpected Arena agent page: {current_url}; "
f"navigating to {redirect_url}"
)
try:
tab.get(redirect_url)
except Exception as navigate_error:
logger.warning(
"[GPT-IMAGE-2] agent-page redirect tab.get() failed, "
f"falling back to location.replace(): {navigate_error}"
)
driver_for_tab(tab).run_js("location.replace(arguments[0])", redirect_url)
return True
def _same_page_url(current_url: str, target_url: str) -> bool:
try:
current = urlsplit(str(current_url or "").strip())
target = urlsplit(str(target_url or "").strip())
return (
current.scheme.lower() == target.scheme.lower()
and current.netloc.lower() == target.netloc.lower()
and current.path.rstrip("/") == target.path.rstrip("/")
)
except Exception:
return False
def _new_image_chat_ready(tab: Any, redirect_url: str) -> bool:
if not _same_page_url(_current_url(tab), redirect_url):
return False
input_box = _find(tab, "css:textarea[name='message']", 1.0)
if not input_box:
return False
try:
return int(as_element(input_box).run_js("return String(this.value || '').length")) == 0
except Exception:
return False
def _visible_image_sources(tab: Any) -> list[str]:
script = f"""
const collect = (images) => Array.from(images)
.filter((img) => {{
const r = img.getBoundingClientRect();
const s = getComputedStyle(img);
return img.isConnected && img.complete && img.naturalWidth >= 256
&& img.naturalHeight >= 256 && r.width >= 120 && r.height >= 120
&& s.display !== 'none' && s.visibility !== 'hidden';
}});
const resultImages = collect(document.querySelectorAll(
{ARENA_RESULT_IMAGE_SELECTOR!r}
));
const images = resultImages.length ? resultImages : collect(document.images);
return images
.sort((a, b) => a.getBoundingClientRect().left - b.getBoundingClientRect().left)
.map((img) => img.currentSrc || img.src)
.filter(Boolean);
"""
try:
return list(dict.fromkeys(str(item) for item in (driver_for_tab(tab).run_js(script) or []) if item))
except Exception:
return []
def _log_image_url(url: str) -> str:
try:
parsed = urlsplit(str(url or ""))
return f"{parsed.scheme}://{parsed.netloc}{parsed.path}"[:200]
except Exception:
return str(url or "").split("?", 1)[0][:200]
def _find(tab: Any, selector: str, timeout: float = 1.0) -> Any:
try:
return driver_for_tab(tab).find(selector, timeout=timeout)
except Exception:
return None
def _upload_reference_image(ctx: dict[str, Any], path: str) -> bool:
tab = ctx["tab"]
logger = ctx["logger"]
image_path = Path(os.path.expandvars(os.path.expanduser(path))).resolve()
if not image_path.is_file():
raise RuntimeError(f"reference_image_missing:{image_path}")
inputs = []
try:
inputs = list(driver_for_tab(tab).find_all('css:input[type="file"]', timeout=1.5) or [])
except Exception:
pass
if not inputs:
for selector in (
"xpath://button[contains(., 'Upload') or contains(., '上传')]",
"css:button[aria-label*='upload' i]",
"css:button[aria-label*='image' i]",
):
button = _find(tab, selector, 0.5)
if button:
try:
button.click()
_sleep(ctx, 0.5)
except Exception:
pass
try:
inputs = list(driver_for_tab(tab).find_all('css:input[type="file"]', timeout=1.0) or [])
except Exception:
inputs = []
if inputs:
break
for file_input in inputs:
try:
file_input.input(str(image_path))
logger.info(f"[GPT-IMAGE-2] reference image uploaded: {image_path.name}")
_sleep(ctx, 2.0)
return True
except Exception as error:
logger.debug(f"[GPT-IMAGE-2] file input upload failed: {error}")
return False
def _refresh_page(ctx: dict[str, Any]) -> None:
tab = ctx["tab"]
try:
tab.refresh()
except Exception:
driver_for_tab(tab).run_js("location.reload()")
_sleep(ctx, 2.0)
def _is_generating(tab: Any) -> bool:
try:
result = driver_for_tab(tab).run_js(
"""
return (() => {
const visible = (element) => {
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
const rect = element.getBoundingClientRect();
const style = getComputedStyle(element);
return rect.width >= 8 && rect.height >= 8
&& style.display !== 'none' && style.visibility !== 'hidden';
};
const hasStopButton = Array.from(document.querySelectorAll(
'button[aria-label="Stop generation"], button[aria-label*="Stop" i], button[data-testid*="stop" i]'
)).some(visible);
if (hasStopButton) return true;
return Array.from(document.querySelectorAll('main *, [role="main"] *'))
.filter(visible)
.some((element) => /^generating\\s+image(?:\\.\\.\\.)?$/i.test(
String(element.textContent || '').trim()
));
})();
"""
)
return result is True
except Exception:
return False
def _is_generation_stopped(tab: Any) -> bool:
try:
result = driver_for_tab(tab).run_js(
"""
return (() => {
const visible = (element) => {
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
const rect = element.getBoundingClientRect();
const style = getComputedStyle(element);
return rect.width >= 8 && rect.height >= 8
&& rect.bottom > 0 && rect.right > 0
&& rect.top < innerHeight && rect.left < innerWidth
&& style.display !== 'none' && style.visibility !== 'hidden';
};
return Array.from(document.querySelectorAll('main *, [role="main"] *'))
.filter(visible)
.some((element) => /^generation\\s+stopped$/i.test(
String(element.textContent || '').trim()
));
})();
"""
)
return result is True
except Exception:
return False
def _stop_generation(ctx: dict[str, Any]) -> bool:
tab = ctx["tab"]
logger = ctx["logger"]
for selector in (
'css:button[aria-label="Stop generation"]',
"css:button[aria-label*='Stop' i]",
"css:button[data-testid*='stop' i]",
):
button = _find(tab, selector, 0.8)
if not button:
continue
try:
button.click()
logger.warning("[GPT-IMAGE-2] generation still active after recovery minute; clicked stop")
_sleep(ctx, 2.0)
return True
except Exception as error:
logger.warning(f"[GPT-IMAGE-2] stop generation click failed: {error}")
logger.error("[GPT-IMAGE-2] generation is active but stop button was not found")
return False
def _stop_generation_and_confirm(ctx: dict[str, Any]) -> bool:
if not _stop_generation(ctx):
return False
deadline = time.time() + 5.0
while time.time() < deadline:
if _is_generation_stopped(ctx["tab"]) or not _is_generating(ctx["tab"]):
return True
_sleep(ctx, 0.25, 0.05)
return False
def _vote_a_better(ctx: dict[str, Any]) -> bool:
tab = ctx["tab"]
logger = ctx["logger"]
script = r"""
return (() => {
const norm = (value) => String(value || '').replace(/\s+/g, ' ').trim().toLowerCase();
const visible = (element) => {
if (!(element instanceof HTMLElement) || !element.isConnected) return false;
const rect = element.getBoundingClientRect();
const style = getComputedStyle(element);
return rect.width >= 8 && rect.height >= 8 && rect.bottom > 0 && rect.right > 0
&& rect.top < innerHeight && rect.left < innerWidth
&& style.display !== 'none' && style.visibility !== 'hidden'
&& style.pointerEvents !== 'none' && Number(style.opacity || '1') > 0.2;
};
const matches = (text) => {
const value = norm(text);
return value.includes('a 更好') || value.includes('a is better')
|| value === 'a better' || value.includes('← a');
};
const elements = Array.from(document.querySelectorAll('button, [role="button"]'));
const button = elements.find((element) => {
const text = element.innerText || element.textContent || element.getAttribute('aria-label');
return visible(element) && !element.disabled
&& element.getAttribute('aria-disabled') !== 'true' && matches(text);
});
if (!button) return false;
button.scrollIntoView({block: 'center', inline: 'center'});
button.click();
return true;
})();
"""
try:
clicked = bool(driver_for_tab(tab).run_js(script))
except Exception as error:
logger.warning(f"[GPT-IMAGE-2] failed to click A better: {error}")
return False
if clicked:
logger.info("[GPT-IMAGE-2] non-target result; selected A better")
_sleep(ctx, 1.0)
else:
logger.warning("[GPT-IMAGE-2] non-target result; A better button was not found")
return clicked
def _start_new_image_chat(ctx: dict[str, Any], redirect_url: str) -> bool:
tab = ctx["tab"]
logger = ctx["logger"]
selectors = (
"css:a[href='/image']",
"xpath://a[contains(., 'New Chat') or contains(., 'New chat')]",
"xpath://button[contains(., 'New Chat') or contains(., 'New chat')]",
)
if _new_image_chat_ready(tab, redirect_url):
logger.stream(f"[GPT-IMAGE-2] new image chat ready: url={_current_url(tab)}")
return True
for selector in selectors:
element = _find(tab, selector, 0.8)
if not element:
continue
try:
element.click()
_sleep(ctx, 1.2)
if _new_image_chat_ready(tab, redirect_url):
logger.stream(f"[GPT-IMAGE-2] new image chat confirmed: url={_current_url(tab)}")
return True
except Exception:
continue
try:
logger.stream(f"[GPT-IMAGE-2] New Chat not confirmed; navigating to {redirect_url}")
tab.get(redirect_url)
_sleep(ctx, 2.0)
return _new_image_chat_ready(tab, redirect_url)
except Exception:
return False
def _send_prompt(
ctx: dict[str, Any], prompt: str, *, require_clear_confirmation: bool = False
) -> bool:
tab = ctx["tab"]
logger = ctx["logger"]
input_box = _find(tab, "css:textarea[name='message']", 5.0)
if not input_box:
return False
if require_clear_confirmation:
try:
replaced = as_element(input_box).run_js(
"""
const value = String(arguments[0] || '');
const setter = Object.getOwnPropertyDescriptor(
HTMLTextAreaElement.prototype, 'value'
).set;
this.focus();
setter.call(this, value);
this.dispatchEvent(new InputEvent('input', {
bubbles: true,
data: value,
inputType: 'insertFromPaste'
}));
this.dispatchEvent(new Event('change', {bubbles: true}));
this.setSelectionRange(value.length, value.length);
return String(this.value || '');
""",
prompt,
)
except Exception as error:
logger.error(f"[GPT-IMAGE-2] failed to replace composer text: {error}")
return False
if str(replaced or "") != prompt:
logger.error("[GPT-IMAGE-2] composer replacement did not match the prompt")
return False
stable_checks = 0
deadline = time.time() + 1.5
while time.time() < deadline:
current_input = _find(tab, "css:textarea[name='message']", 0.3)
try:
current_value = str(
as_element(current_input).run_js("return String(this.value || '')") if current_input else ""
)
except Exception:
current_value = ""
if current_value == prompt:
stable_checks += 1
if stable_checks >= 3:
break
else:
stable_checks = 0
_sleep(ctx, 0.15, 0.05)
if stable_checks < 3:
logger.error("[GPT-IMAGE-2] controlled composer restored or changed the prompt")
return False
def composer_is_empty() -> bool:
current_input = _find(tab, "css:textarea[name='message']", 0.3)
if not current_input:
return False
try:
return int(as_element(current_input).run_js("return String(this.value || '').length")) == 0
except Exception:
return False
def wait_until_sent(timeout: float = 3.0) -> bool:
deadline = time.time() + timeout
while time.time() < deadline:
if composer_is_empty():
return True
_sleep(ctx, 0.15, 0.05)
return False
button = _find(
tab,
"css:button[aria-label='Send message'][type='submit']:not(:disabled), "
"button[type='submit']:not([aria-label='Stop generation']):not(:disabled)",
1.0,
)
if button:
try:
button.click()
except Exception as error:
logger.warning(f"[GPT-IMAGE-2] send button click failed: {error}")
else:
logger.warning("[GPT-IMAGE-2] send button not found")
if wait_until_sent():
logger.stream("[GPT-IMAGE-2] send confirmed after button click")
return True
for enter_attempt in range(2):
current_input = _find(tab, "css:textarea[name='message']", 0.5)
if not current_input:
logger.warning("[GPT-IMAGE-2] composer missing before Enter fallback")
else:
try:
current_input.input("\n")
except Exception as error:
logger.warning(
f"[GPT-IMAGE-2] Enter fallback failed: "
f"attempt={enter_attempt + 1}/2 error={error}"
)
if wait_until_sent():
logger.stream(
f"[GPT-IMAGE-2] send confirmed after Enter: attempt={enter_attempt + 1}/2"
)
return True
logger.warning(
f"[GPT-IMAGE-2] composer still contains text after Enter: "
f"attempt={enter_attempt + 1}/2"
)
return False
try:
input_box.clear()
except Exception:
pass
input_box.input(prompt)
_sleep(ctx, 0.3)
before_url = _current_url(tab)
def submission_confirmed(timeout: float = 2.0) -> bool:
deadline = time.time() + timeout
while time.time() < deadline:
current_url = _current_url(tab)
if current_url and current_url != before_url:
return True
try:
if int(as_element(input_box).run_js("return String(this.value || '').length")) == 0:
return True
except Exception:
pass
for selector in (
"css:button[aria-label*='Stop' i]",
"css:button[data-testid*='stop' i]",
"css:[aria-busy='true']",
):
if _find(tab, selector, 0.15):
return True
_sleep(ctx, 0.15, 0.05)
return False
for attempt in range(2):
try:
input_box.input("\n")
except Exception as error:
if isinstance(error, RuntimeError) and "cancelled" in str(error).lower():
raise
logger.warning(
f"[GPT-IMAGE-2] Enter submit failed: attempt={attempt + 1}/2 error={error}"
)
if submission_confirmed(2.5):
logger.stream(f"[GPT-IMAGE-2] Enter submit confirmed: attempt={attempt + 1}/2")
return True
if attempt == 0:
logger.stream("[GPT-IMAGE-2] Enter submit not confirmed; retrying Enter")
_sleep(ctx, 0.5)
button = _find(tab, "css:button[type='submit']", 1.0)
if button:
try:
logger.stream("[GPT-IMAGE-2] Enter submit not confirmed; trying send button")
button.click()
if submission_confirmed(2.5):
logger.stream("[GPT-IMAGE-2] send button submit confirmed")
return True
except Exception as error:
logger.warning(f"[GPT-IMAGE-2] send button fallback failed: {error}")
return False
def _wait_for_gpt_image2(
ctx: dict[str, Any],
baseline: set[str],
timeout: float,
reference_signature: dict[str, Any] | None = None,
) -> tuple[list[dict[str, Any]], list[str]]:
tab = ctx["tab"]
logger = ctx["logger"]
deadline = time.time() + timeout
inspected: dict[str, str] = {}
matches: list[dict[str, Any]] = []
candidates: list[str] = []
last_new_image_at = 0.0
while time.time() < deadline:
_sleep(ctx, 0.5)
sources = [url for url in _visible_image_sources(tab) if url not in baseline]
if sources:
last_new_image_at = last_new_image_at or time.time()
for side_index, url in enumerate(sources):
if url in inspected:
continue
payload = _read_image_bytes(tab, url)
if not payload:
continue
signatures = _image_signatures(payload)
inspected[url] = signatures["sha256"]
if _same_image(signatures, reference_signature):
logger.info(
f"[GPT-IMAGE-2] skipped submitted reference image: "
f"side={'A' if side_index == 0 else 'B'} "
f"url={_log_image_url(url)}"
)
continue
if url not in candidates:
candidates.append(url)
evidence = inspect_gpt_image2_png(payload)
logger.info(
f"[GPT-IMAGE-2][C2PA] side={'A' if side_index == 0 else 'B'} "
f"matched={evidence['matched']} reason={evidence['reason']} "
f"bytes={len(payload)} url={_log_image_url(url)}"
)
if evidence["matched"]:
matches.append({"url": url, "side": "A" if side_index == 0 else "B", **evidence})
generation_done = _is_generation_stopped(tab) or not _is_generating(tab)
if (
last_new_image_at
and time.time() - last_new_image_at >= 4.0
and generation_done
):
# Arena can reuse a URL while replacing an early preview with the
# final PNG, so force one content-aware pass after generation ends.
final_sources = [
url for url in _visible_image_sources(tab) if url not in baseline
]
for side_index, url in enumerate(final_sources):
payload = _read_image_bytes(tab, url)
if not payload:
continue
signatures = _image_signatures(payload)
final_side = "A" if side_index == 0 else "B"
if inspected.get(url) == signatures["sha256"]:
for match in matches:
if match.get("url") == url:
match["side"] = final_side
continue
inspected[url] = signatures["sha256"]
if _same_image(signatures, reference_signature):
continue
if url not in candidates:
candidates.append(url)
evidence = inspect_gpt_image2_png(payload)
logger.info(
f"[GPT-IMAGE-2][C2PA][FINAL] "
f"side={final_side} "
f"matched={evidence['matched']} reason={evidence['reason']} "
f"bytes={len(payload)} url={_log_image_url(url)}"
)
if evidence["matched"]:
matches.append(
{
"url": url,
"side": final_side,
**evidence,
}
)
break
unique_matches = list(
{item.get("url", ""): item for item in matches if item.get("url")}.values()
)
return unique_matches, candidates
def _recover_timed_out_generation(
ctx: dict[str, Any],
initial_matches: list[dict[str, Any]],
initial_candidates: list[str],
reference_signature: dict[str, Any] | None = None,
) -> tuple[list[dict[str, Any]], list[str], bool]:
tab = ctx["tab"]
logger = ctx["logger"]
matches = list(initial_matches)
candidates = list(initial_candidates)
_refresh_page(ctx)
if _is_generating(tab):
logger.warning("[GPT-IMAGE-2] generation still active after refresh; stopping immediately")
if not _stop_generation_and_confirm(ctx):
raise _StopGenerationFailure(
"generation_still_active_after_stop; command loop terminated"
)
logger.info("[GPT-IMAGE-2] timed-out generation stopped; continuing next round")
return matches, candidates, True
else:
logger.info("[GPT-IMAGE-2] generation completed after refresh; inspecting current images")
recovered_matches, recovered_candidates = _wait_for_gpt_image2(
ctx, set(), 5.0, reference_signature
)
matches.extend(recovered_matches)
candidates.extend(recovered_candidates)
unique_matches = list({item.get("url", ""): item for item in matches if item.get("url")}.values())
unique_candidates = list(dict.fromkeys(url for url in candidates if url))
return unique_matches, unique_candidates, False
class _StopGenerationFailure(RuntimeError):
pass
def run(ctx: dict[str, Any], *, single_mode: bool = False) -> str:
tab = ctx["tab"]
logger = ctx["logger"]
session = ctx.get("session")
current_command_id = str(getattr(session, "_current_command_id", "") or "").strip()
current_command_name = str(getattr(session, "current_command_name", "") or "").strip()
single_mode = bool(
single_mode
or current_command_id == "cmd_15d91034"
or current_command_name == "ARENA自动盲测不翻牌 -gpt image 2 - 单"
)
ui = ctx.get("command_ui") if isinstance(ctx.get("command_ui"), dict) else {}
values = ui.get("values") if isinstance(ui.get("values"), dict) else ui
values = values if isinstance(values, dict) else {}
total_runs = max(1, int(_value(values, "total_runs", 20)))
prompt = str(_value(values, "prompt_text", "Create an image.")).strip()
random_chars = str(_value(values, "random_insert_chars", "abcdefghijklmnopqrstuvwxyz"))
reference_image = str(_value(values, "reference_image", "")).strip()
reference_signature = None
if reference_image:
reference_path = Path(
os.path.expandvars(os.path.expanduser(reference_image))
).resolve()
if reference_path.is_file():
reference_signature = _image_signatures(reference_path.read_bytes())
generation_mode = "image-to-image" if reference_image else "text-to-image"
timeout = 150.0 if single_mode else min(
100.0,
max(1.0, float(_value(values, "wait_reply_timeout_sec", 100))),
)
redirect_url = str(_value(values, "redirect_url", "https://arena.ai/image")).strip()
ctx["_arena_agent_guard"] = lambda: _redirect_if_agent_page(ctx, redirect_url)
hit_urls: list[str] = []
consecutive_send_failures = 0
logger.stream(
f"[GPT-IMAGE-2] starting {total_runs} rounds; "
f"mode={generation_mode}; timeout={timeout:g}s"
)
for index in range(total_runs):
status = "completed"
ctx["begin_command_loop"](index + 1, total_runs, "Arena GPT Image 2")
try:
if _redirect_if_agent_page(ctx, redirect_url):
raise RuntimeError("arena_agent_redirected")
if not single_mode:
logger.stream(
f"[GPT-IMAGE-2] round {index + 1}/{total_runs}: creating a new image chat"
)
if not _start_new_image_chat(ctx, redirect_url):
raise RuntimeError("new_image_chat_failed")
if reference_image and not _upload_reference_image(ctx, reference_image):
raise RuntimeError("reference_image_upload_failed")
baseline = set(_visible_image_sources(tab))
run_prompt = prompt
if random_chars:
position = random.randint(0, len(run_prompt))
run_prompt = run_prompt[:position] + random.choice(random_chars) + run_prompt[position:]
logger.stream(f"[GPT-IMAGE-2] round {index + 1}/{total_runs}: sending prompt")
if not _send_prompt(
ctx,
run_prompt,
require_clear_confirmation=single_mode,
):
if not single_mode:
raise RuntimeError("send_failed")
consecutive_send_failures += 1
status = "failed"
logger.error(
f"[GPT-IMAGE-2] send failed {consecutive_send_failures} consecutive rounds; "
"recovering the stuck page before the next round"
)
_refresh_page(ctx)
if _is_generating(tab):
logger.warning(
"[GPT-IMAGE-2] stale generation remained after failed send; stopping it"
)
if not _stop_generation_and_confirm(ctx):
raise _StopGenerationFailure(
"generation_still_active_after_stop; command loop terminated"
)
continue
consecutive_send_failures = 0
matches, candidates = _wait_for_gpt_image2(
ctx, baseline, timeout, reference_signature
)
if single_mode and not matches and _is_generation_stopped(tab):
logger.info(
f"[GPT-IMAGE-2] round {index + 1}/{total_runs} generation stopped "
"without a target match; continuing next round without voting"
)
continue
if single_mode and (_is_generating(tab) or not candidates):
logger.warning(
f"[GPT-IMAGE-2] round {index + 1}/{total_runs} reached {timeout:g}s "
"without a completed image response; refreshing within the same round"
)
matches, candidates, interrupted = _recover_timed_out_generation(
ctx, matches, candidates, reference_signature
)
if interrupted:
continue
page_url = _current_url(tab)
if matches:
info = {
"url": page_url,
"response_sides": [
f"gpt-image 2.0 OpenAI Media Service API mode:{generation_mode}"
if item["side"] == side else "other image model"
for side in ("A", "B")
for item in matches[:1]
],
}
record_result = ctx["record_arena_rule_candidates"](
info,
run_prompt,
source="image-c2pa/gpt-image-2",
)
if page_url and page_url not in hit_urls:
hit_urls.append(page_url)
logger.info(
f"[GPT-IMAGE-2][HIT] sides={','.join(item['side'] for item in matches)} "
f"url={page_url} drawer_matches={record_result.get('matched', 0)}"
)
if single_mode:
break
elif single_mode:
logger.info(
f"[GPT-IMAGE-2] no GPT Image 2 C2PA match; images={len(candidates)} url={page_url}"
)
if candidates:
_vote_a_better(ctx)
else:
logger.info(
f"[GPT-IMAGE-2] no GPT Image 2 C2PA match; images={len(candidates)} url={page_url}"
)
except _StopGenerationFailure:
status = "failed"
raise
except RuntimeError as error:
if str(error) in {"python_script_cancelled", "python_script_loop_cancelled"}:
status = "cancelled"
if str(error) == "python_script_cancelled":
break
elif str(error) == "arena_agent_redirected":
status = "failed"
logger.warning(
f"[GPT-IMAGE-2] round {index + 1} treated as abnormal because the page was /agent"
)
else:
status = "failed"
logger.error(f"[GPT-IMAGE-2] round {index + 1} failed: {error}")
if not single_mode:
try:
tab.get(redirect_url)
_sleep(ctx, 2.0)
except Exception:
pass
except Exception as error:
status = "failed"
logger.error(f"[GPT-IMAGE-2] round {index + 1} failed: {error}")
finally:
ctx["end_command_loop"](status)
if hit_urls:
return "GPT Image 2 C2PA hit URLs:\n" + "\n".join(
f"{index}. {url}" for index, url in enumerate(hit_urls, 1)
)
return "GPT Image 2 C2PA hits: 0"
__all__ = ["GPT_IMAGE_MARKERS", "inspect_gpt_image2_png", "run"]