Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix(image): use standalone Codex Images API (#6177)
chengyongrubdfc8f7bd488
diff --git a/docs/image-generation.md b/docs/image-generation.mdindex 892ececaa..eb0539e31 100644--- a/docs/image-generation.md+++ b/docs/image-generation.md@@ -96,6 +96,26 @@ OpenRouter uses a chat-completions style image response. Configure:Use a model that supports image generation and image editing if you want reference-image edits.+### OpenAI Codex++Log in with `nanobot provider login openai-codex`, then select **OpenAI Codex** and `gpt-image-2` under **Settings → Image**. Image generation uses your Codex subscription.++For manual configuration:++```json+{+ "tools": {+ "imageGeneration": {+ "enabled": true,+ "provider": "openai_codex",+ "model": "gpt-image-2"+ }+ }+}+```++Use Codex to generate images from text or edit existing images with reference images.+### Custom (OpenAI-compatible)The `custom` image provider fits services that implement the synchronous OpenAI Images API:diff --git a/nanobot/providers/image_generation.py b/nanobot/providers/image_generation.pyindex 996e63b9b..f5c607e13 100644--- a/nanobot/providers/image_generation.py+++ b/nanobot/providers/image_generation.py@@ -1371,13 +1371,13 @@ class CustomImageGenerationClient(ImageGenerationProvider):class CodexImageGenerationClient(ImageGenerationProvider):"""OpenAI image generation via Codex subscription OAuth.- Uses the Codex Responses API with the ``image_generation`` tool- (the same mechanism ChatGPT uses internally). No API key required —- the Codex OAuth token from ``oauth_cli_kit`` is used instead.+ Uses the standalone Codex Images API, matching the official Codex+ image-generation extension. The Codex OAuth token from ``oauth_cli_kit``+ authenticates requests without an API key."""provider_name = "openai_codex"- model_options = ("gpt-5.4",)+ model_options = ("gpt-image-2",)missing_key_message = ("Codex OAuth token is unavailable. ""Log in with Codex subscription first."@@ -1417,63 +1417,56 @@ class CodexImageGenerationClient(ImageGenerationProvider):if not token or not token.access:raise ImageGenerationError(self.missing_key_message)- logger.info(- "Using Codex OAuth token for image generation (account: {})",- token.account_id,- )-- if reference_images:- logger.warning(- "Codex image generation does not support reference images; "- "ignoring {} reference image(s)",- len(reference_images),- )-headers: dict[str, str] = {"Authorization": f"Bearer {token.access}","chatgpt-account-id": str(token.account_id),- "OpenAI-Beta": "responses=experimental","originator": "nanobot","User-Agent": "nanobot (python)","Content-Type": "application/json",**self.extra_headers,}-+ clean_model = self._codex_model(model)body: dict[str, Any] = {- "model": self._codex_model(model),- "instructions": "Generate an image based on the user's request.",- "input": [{"role": "user", "content": prompt}],- "tools": [{"type": "image_generation"}],- "tool_choice": "auto",- "stream": True,- "store": False,+ "model": clean_model,+ "prompt": prompt,+ "background": "opaque",+ "quality": "auto",+ "size": (+ _openai_size(clean_model, aspect_ratio, image_size)+ if aspect_ratio or image_size else "auto"+ ),}body.update(self.extra_body)+ body = {key: value for key, value in body.items() if value is not None}+ endpoint = "generations"+ if reference_images:+ endpoint = "edits"+ body["images"] = [+ {"image_url": image_path_to_data_url(path)} for path in reference_images+ ]- logger.info("Codex Responses API request: POST {}/codex/responses body={}",- self.api_base, {k: v for k, v in body.items() if k != "input"})-+ base = self.api_base+ if not base.endswith("/codex"):+ base = f"{base}/codex"response = await self._http_post(- f"{self.api_base}/codex/responses",+ f"{base}/images/{endpoint}",headers=headers,body=body,)-try:response.raise_for_status()except httpx.HTTPStatusError as exc:detail = response.text[:1000]- logger.error("Codex Responses API error ({}): {}", response.status_code, detail)raise ImageGenerationError(f"Codex image generation failed (HTTP {response.status_code}): {detail}") from exc- images, content_text = await _parse_codex_sse_images(response)-- raw = {"status": "completed"}- self._require_images(images, raw)-- return GeneratedImageResponse(images=images, content=content_text, raw=raw)+ payload = _as_json_object(response.json())+ if payload is None:+ raise ImageGenerationError("Codex image generation returned an invalid JSON response")+ images = await _openai_images_from_payload(payload, proxy=self.proxy)+ self._require_images(images, payload)+ return GeneratedImageResponse(images=images, content="", raw=payload)def _openai_size(@@ -1572,93 +1565,6 @@ async def _openai_images_from_payload(return images-async def _parse_codex_sse_images(- response: httpx.Response,-) -> tuple[list[str], str]:- """Parse a Codex Responses API SSE stream for image generation output.-- Returns ``(images, content_text)``.- """- import json as _json-- images: list[str] = []- text_parts: list[str] = []-- buffer: list[str] = []- async for line_bytes in response.aiter_lines():- line = line_bytes.strip()- if line == "":- if buffer:- data_lines: list[str] = []- for bl in buffer:- if bl.startswith("data:"):- data_lines.append(bl[5:].strip())- buffer.clear()- if data_lines:- raw = "".join(data_lines)- if raw == "[DONE]":- break- try:- event = _as_json_object(_json.loads(raw))- except Exception:- continue- if event is None:- continue- ev_type = event.get("type", "")- if ev_type in ("error", "response.failed"):- logger.error("Codex SSE failure: {}", raw[:2000])- _collect_images_from_sse_event(event, images)- _collect_text_from_sse_event(event, text_parts)- if ev_type == "response.completed":- break- continue- buffer.append(line)-- # flush remaining- if buffer:- data_lines = [bl[5:].strip() for bl in buffer if bl.startswith("data:")]- raw = "".join(data_lines)- if raw and raw != "[DONE]":- try:- event = _as_json_object(_json.loads(raw))- except Exception:- pass- else:- if event is not None:- _collect_images_from_sse_event(event, images)- _collect_text_from_sse_event(event, text_parts)-- return images, "".join(text_parts).strip()---def _collect_images_from_sse_event(event: dict[str, Any], images: list[str]) -> None:- if event.get("type") != "response.output_item.done":- return- item = _as_json_object(event.get("item")) or {}- if item.get("type") != "image_generation_call":- return- result = item.get("result")- if isinstance(result, str):- if result.startswith("data:image/"):- images.append(result)- else:- images.append(_b64_image_data_url(result))- elif (result_object := _as_json_object(result)) is not None:- image_url = result_object.get("image_url") or result_object.get("image") or ""- if isinstance(image_url, str):- if image_url.startswith("data:image/"):- images.append(image_url)- else:- images.append(_b64_image_data_url(image_url))---def _collect_text_from_sse_event(event: dict[str, Any], text_parts: list[str]) -> None:- if event.get("type") == "response.output_text.delta":- delta = event.get("delta")- if isinstance(delta, str) and delta:- text_parts.append(delta)--# ---------------------------------------------------------------------------# StepFun (阶跃星辰) image generation# ---------------------------------------------------------------------------diff --git a/tests/providers/test_image_generation.py b/tests/providers/test_image_generation.pyindex f7580827c..93441b91d 100644--- a/tests/providers/test_image_generation.py+++ b/tests/providers/test_image_generation.py@@ -42,14 +42,12 @@ class FakeResponse:payload: dict[str, Any],status_code: int = 200,content: bytes = b"",- sse_lines: list[str] | None = None,) -> None:self._payload = payloadself.status_code = status_codeself.text = str(payload)self.content = contentself.request = httpx.Request("POST", "https://openrouter.ai/api/v1/chat/completions")- self._sse_lines = sse_linesdef json(self) -> dict[str, Any]:return self._payload@@ -59,15 +57,6 @@ class FakeResponse:response = httpx.Response(self.status_code, request=self.request, text=self.text)raise httpx.HTTPStatusError("failed", request=self.request, response=response)- async def aiter_lines(self):- if self._sse_lines is not None:- for line in self._sse_lines:- yield line- return- # Fallback: treat response text as SSE lines- for line in self.text.split("\n"):- yield line-class FakeClient:def __init__(self, response: FakeResponse) -> None:@@ -85,23 +74,6 @@ class FakeClient:return self.get_response-class CodexStreamingCompleteThenErrorResponse(FakeResponse):- async def aiter_lines(self):- yield 'data: {"type":"response.output_item.added","item":{"id":"ig_1","type":"image_generation_call","status":"in_progress"}}'- yield ""- yield (- f'data: {{"type":"response.output_item.done","item":{{"id":"ig_1",'- f'"type":"image_generation_call","result":"{PNG_DATA_URL}","status":"completed"}}}}'- )- yield ""- yield 'data: {"type":"response.completed","response":{"status":"completed"}}'- yield ""- raise httpx.RemoteProtocolError(- "peer closed connection without sending complete message body "- "(incomplete chunked read)"- )--@pytest.fixture(autouse=True)def generated_image_downloads(monkeypatch) -> list[tuple[str, str | None]]:"""Keep provider response parsing tests independent from outbound HTTP."""@@ -1238,82 +1210,61 @@ async def test_custom_generate_http_error() -> None:# ----------------------------------------------------------------------------async def test_codex_payload_and_response(monkeypatch) -> None:+def codex_oauth(monkeypatch):import sys- from dataclasses import dataclassfrom types import SimpleNamespace- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"+ calls: list[dict[str, Any]] = []- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)+ def get_token(**kwargs):+ calls.append(kwargs)+ return SimpleNamespace(account_id="acct-123", access="oauth-token")- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- sse_lines = [- 'data: {"type":"response.output_item.added","item":{"id":"ig_1","type":"image_generation_call","status":"in_progress"}}',- "",- f'data: {{"type":"response.output_item.done","item":{{"id":"ig_1","type":"image_generation_call","result":"{PNG_DATA_URL}","status":"completed"}}}}',- "",- 'data: [DONE]',- "",- ]- fake = FakeClient(FakeResponse({}, sse_lines=sse_lines))- client = CodexImageGenerationClient(- api_key=None,- api_base="https://chatgpt.com/backend-api",- extra_headers={"X-Test": "1"},- client=fake, # type: ignore[arg-type]- )+ monkeypatch.setitem(sys.modules, "oauth_cli_kit", SimpleNamespace(get_token=get_token))+ return calls- response = await client.generate(- prompt="draw a cat",- model="gpt-5.4",- )+[email protected]("base", [+ "https://chatgpt.com/backend-api",+ "https://chatgpt.com/backend-api/codex/",+])+async def test_codex_payload_and_response(codex_oauth, base: str) -> None:+ import json++ requests: list[httpx.Request] = []+ payload = {"created": 1778832973, "data": [{"b64_json": PNG_DATA_URL.split(",")[1]}]}++ def handle(request: httpx.Request) -> httpx.Response:+ requests.append(request)+ return httpx.Response(200, json=payload)++ async with httpx.AsyncClient(transport=httpx.MockTransport(handle)) as http:+ client = CodexImageGenerationClient(+ api_key=None, api_base=base, extra_headers={"X-Test": "1"}, client=http,+ )+ response = await client.generate(prompt="draw a cat", model=client.model_options[0])assert response.images == [PNG_DATA_URL]assert response.content == ""- call = fake.calls[0]- assert call["url"] == "https://chatgpt.com/backend-api/codex/responses"- assert call["headers"]["Authorization"] == "Bearer oauth-token"- assert call["headers"]["chatgpt-account-id"] == "acct-123"- assert call["headers"]["OpenAI-Beta"] == "responses=experimental"- assert call["headers"]["X-Test"] == "1"- body = call["json"]- assert body["model"] == "gpt-5.4"- assert body["instructions"] == "Generate an image based on the user's request."- assert body["input"] == [{"role": "user", "content": "draw a cat"}]- assert body["tools"] == [{"type": "image_generation"}]- assert body["tool_choice"] == "auto"- assert body["store"] is False- assert body["stream"] is True+ assert response.raw == payload+ request = requests[0]+ assert str(request.url) == "https://chatgpt.com/backend-api/codex/images/generations"+ assert request.headers["Authorization"] == "Bearer oauth-token"+ assert request.headers["chatgpt-account-id"] == "acct-123"+ assert request.headers["X-Test"] == "1"+ assert json.loads(request.content) == {+ "model": "gpt-image-2", "prompt": "draw a cat",+ "background": "opaque", "quality": "auto", "size": "auto",+ }@pytest.mark.asyncio-async def test_codex_proxy_applies_to_oauth_and_http(monkeypatch) -> None:- import sys- from types import SimpleNamespace-+async def test_codex_proxy_applies_to_oauth_and_http(monkeypatch, codex_oauth) -> None:proxy = "http://127.0.0.1:23458"captured: dict[str, Any] = {}- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- def fake_get_token(*, proxy=None):- captured["token_proxy"] = proxy- return SimpleNamespace(account_id="acct-123", access="oauth-token")-- fake_oauth = SimpleNamespace(get_token=fake_get_token)- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-class FakeAsyncClient:def __init__(self, **kwargs: Any) -> None:captured["client_kwargs"] = kwargs@@ -1326,90 +1277,46 @@ async def test_codex_proxy_applies_to_oauth_and_http(monkeypatch) -> None:async def post(self, url: str, **kwargs: Any) -> FakeResponse:captured["request"] = {"url": url, **kwargs}- return FakeResponse(- {},- sse_lines=[- f'data: {{"type":"response.output_item.done","item":{{"type":"image_generation_call","result":"{PNG_DATA_URL}"}}}}',- "",- "data: [DONE]",- "",- ],- )+ return FakeResponse({"data": [{"b64_json": PNG_DATA_URL.split(",")[1]}]})- monkeypatch.setattr(- "nanobot.providers.image_generation.httpx.AsyncClient",- FakeAsyncClient,- )+ monkeypatch.setattr("nanobot.providers.image_generation.httpx.AsyncClient", FakeAsyncClient)client = CodexImageGenerationClient(api_key=None, proxy=proxy)-- response = await client.generate(prompt="draw", model="gpt-5.4")-+ response = await client.generate(prompt="draw", model="gpt-image-2")assert response.images == [PNG_DATA_URL]- assert captured["token_proxy"] == proxy+ assert codex_oauth == [{"proxy": proxy}]assert captured["client_kwargs"]["proxy"] == proxyassert captured["client_kwargs"]["trust_env"] is False@pytest.mark.asyncio-async def test_codex_stops_reading_after_completed_event(monkeypatch) -> None:- import sys- from dataclasses import dataclass- from types import SimpleNamespace-- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"-- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- fake = FakeClient(CodexStreamingCompleteThenErrorResponse({}, sse_lines=[]))[email protected]("prefix", ["openai-codex", "openai_codex"])+async def test_codex_edit_reference_images_and_options(codex_oauth, tmp_path, prefix) -> None:+ reference = tmp_path / "reference.png"+ reference.write_bytes(PNG_BYTES)+ fake = FakeClient(FakeResponse({"data": [{"b64_json": PNG_DATA_URL.split(",")[1]}]}))client = CodexImageGenerationClient(- api_key=None, client=fake # type: ignore[arg-type]+ api_key=None, extra_body={"quality": "high", "background": None},+ client=fake, # type: ignore[arg-type]+ )+ response = await client.generate(+ prompt="add a hat", model=f"{prefix}/gpt-image-2",+ reference_images=[str(reference)], aspect_ratio="16:9",)-- response = await client.generate(prompt="draw a cat", model="gpt-5.4")-assert response.images == [PNG_DATA_URL]- assert response.content == ""+ assert fake.calls[0]["url"] == "https://chatgpt.com/backend-api/codex/images/edits"+ assert fake.calls[0]["json"] == {+ "model": "gpt-image-2", "prompt": "add a hat", "quality": "high",+ "size": "1536x1024",+ "images": [{"image_url": "data:image/png;base64," + base64.b64encode(PNG_BYTES).decode()}],+ }@pytest.mark.asyncio-async def test_codex_strips_model_prefix(monkeypatch) -> None:- import sys- from dataclasses import dataclass- from types import SimpleNamespace-- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"-- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- fake = FakeClient(FakeResponse({}, sse_lines=[- f'data: {{"type":"response.output_item.done","item":{{"type":"image_generation_call","result":"{PNG_DATA_URL}"}}}}',- "",- 'data: [DONE]',- "",- ]))- client = CodexImageGenerationClient(- api_key=None, client=fake # type: ignore[arg-type]- )-- await client.generate(prompt="draw", model="openai-codex/gpt-5.4")-- assert fake.calls[0]["json"]["model"] == "gpt-5.4"+async def test_codex_explicit_size(codex_oauth) -> None:+ fake = FakeClient(FakeResponse({"data": [{"b64_json": PNG_DATA_URL.split(",")[1]}]}))+ client = CodexImageGenerationClient(api_key=None, client=fake) # type: ignore[arg-type]+ await client.generate(prompt="draw", model="gpt-image-2", image_size="2048x1152")+ assert fake.calls[0]["json"]["size"] == "2048x1152"@pytest.mark.asyncio@@ -1418,115 +1325,25 @@ async def test_codex_requires_oauth(monkeypatch) -> None:raise RuntimeError("no token")monkeypatch.setattr("asyncio.to_thread", fake_to_thread)-client = CodexImageGenerationClient(api_key=None)-with pytest.raises(ImageGenerationError, match="OAuth token"):- await client.generate(prompt="draw", model="gpt-5.4")+ await client.generate(prompt="draw", model="gpt-image-2")@pytest.mark.asyncio-async def test_codex_no_images_raises(monkeypatch) -> None:- import sys- from dataclasses import dataclass- from types import SimpleNamespace-- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"-- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- fake = FakeClient(FakeResponse({}, sse_lines=[- 'data: {"type":"response.completed","response":{"status":"completed"}}',- "",- 'data: [DONE]',- "",- ]))- client = CodexImageGenerationClient(- api_key=None, client=fake # type: ignore[arg-type]- )-+async def test_codex_no_images_raises(codex_oauth) -> None:+ fake = FakeClient(FakeResponse({"data": []}))+ client = CodexImageGenerationClient(api_key=None, client=fake) # type: ignore[arg-type]with pytest.raises(ImageGenerationError, match="returned no images"):- await client.generate(prompt="draw", model="gpt-5.4")+ await client.generate(prompt="draw", model="gpt-image-2")@pytest.mark.asyncio-async def test_codex_extracts_text_content(monkeypatch) -> None:- import sys- from dataclasses import dataclass- from types import SimpleNamespace-- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"-- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- fake = FakeClient(FakeResponse({}, sse_lines=[- 'data: {"type":"response.output_text.delta","delta":"Here "}',- "",- 'data: {"type":"response.output_text.delta","delta":"is your cat image."}',- "",- f'data: {{"type":"response.output_item.done","item":{{"type":"image_generation_call","result":"{PNG_DATA_URL}"}}}}',- "",- 'data: [DONE]',- "",- ]))- client = CodexImageGenerationClient(- api_key=None, client=fake # type: ignore[arg-type]- )-- response = await client.generate(prompt="draw a cat", model="gpt-5.4")-- assert response.images == [PNG_DATA_URL]- assert response.content == "Here is your cat image."---async def test_codex_json_result_format(monkeypatch) -> None:- """image_generation_call result can be a dict with image_url key."""- import sys- from dataclasses import dataclass- from types import SimpleNamespace-- @dataclass- class FakeToken:- account_id: str = "acct-123"- access: str = "oauth-token"-- async def fake_to_thread(fn, *args, **kwargs):- return fn(*args, **kwargs)-- monkeypatch.setattr("asyncio.to_thread", fake_to_thread)- fake_oauth = SimpleNamespace(get_token=lambda: FakeToken())- monkeypatch.setitem(sys.modules, "oauth_cli_kit", fake_oauth)-- fake = FakeClient(FakeResponse({}, sse_lines=[- f'data: {{"type":"response.output_item.done","item":{{"type":"image_generation_call","result":{{"image_url":"{PNG_DATA_URL}"}}}}}}',- "",- 'data: [DONE]',- "",- ]))- client = CodexImageGenerationClient(- api_key=None, client=fake # type: ignore[arg-type]- )-- response = await client.generate(prompt="draw", model="gpt-5.4")-- assert response.images == [PNG_DATA_URL]+async def test_codex_http_error(codex_oauth) -> None:+ fake = FakeClient(FakeResponse({"error": {"message": "image quota exceeded"}}, status_code=429))+ client = CodexImageGenerationClient(api_key=None, client=fake) # type: ignore[arg-type]+ with pytest.raises(ImageGenerationError, match="HTTP 429.*image quota exceeded"):+ await client.generate(prompt="draw", model="gpt-image-2")@pytest.mark.asynciodiff --git a/tests/tools/test_image_generation_tool.py b/tests/tools/test_image_generation_tool.pyindex 6aa06635b..29895ce20 100644--- a/tests/tools/test_image_generation_tool.py+++ b/tests/tools/test_image_generation_tool.py@@ -140,7 +140,7 @@ def test_image_generation_tool_passes_provider_proxy_to_client(config=ImageGenerationToolConfig(enabled=True,provider="openai_codex",- model="openai-codex/gpt-5.4",+ model="openai-codex/gpt-image-2",),provider_configs={"openai_codex": ProviderConfig(proxy=proxy)},)