code-puppy 0.0.652__tar.gz → 0.0.653__tar.gz

{code_puppy-0.0.652 → code_puppy-0.0.653}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.652
+Version: 0.0.653
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.652 → code_puppy-0.0.653}/code_puppy/command_line/model_settings_menu.py

@@ -83,6 +83,20 @@ SETTING_DEFINITIONS: Dict[str, Dict] = {
         "choices": ["minimal", "low", "medium", "high", "xhigh", "ultra"],
         "default": "medium",
     },
+    "reasoning_context": {
+        "name": "Reasoning Context",
+        "description": "Controls which prior reasoning is retained for GPT-5.6 Responses models. All turns preserves reasoning across the conversation.",
+        "type": "choice",
+        "choices": ["all_turns", "current_turn", "auto"],
+        "default": "all_turns",
+    },
+    "reasoning_mode": {
+        "name": "Reasoning Mode",
+        "description": "Controls the GPT-5.6 reasoning mode. Standard is the default; Pro spends more compute and is only available on supported variants.",
+        "type": "choice",
+        "choices": ["standard", "pro"],
+        "default": "standard",
+    },
     "summary": {
         "name": "Reasoning Summary",
         "description": "Controls whether OpenAI Responses models return auto, concise, or detailed reasoning summaries.",
@@ -267,6 +281,10 @@ def _get_model_display_settings(model_name: str) -> Dict:
 
     if model_supports_setting(model_name, "reasoning_effort"):
         settings["reasoning_effort"] = get_openai_reasoning_effort()
+    if model_supports_setting(model_name, "reasoning_context"):
+        settings.setdefault("reasoning_context", "all_turns")
+    if model_supports_setting(model_name, "reasoning_mode"):
+        settings.setdefault("reasoning_mode", "standard")
     if model_supports_setting(model_name, "summary"):
         settings["summary"] = get_openai_reasoning_summary()
     if model_supports_setting(model_name, "verbosity"):

{code_puppy-0.0.652 → code_puppy-0.0.653}/code_puppy/config.py

@@ -689,12 +689,22 @@ def model_supports_setting(model_name: str, setting: str) -> bool:
 
         if supports_glm_reasoning_effort(model_name):
             return True
+    if setting in ("reasoning_context", "reasoning_mode"):
+        # OpenAI added these Responses API controls with GPT-5.6. Capability
+        # detection belongs here so injected/custom 5.6 model definitions do
+        # not all need to duplicate the same supported_settings metadata.
+        if "gpt-5.6" in model_name.lower():
+            return True
 
     try:
         from code_puppy.model_factory import ModelFactory
 
         models_config = ModelFactory.load_config()
         model_config = models_config.get(model_name, {})
+        if setting in ("reasoning_context", "reasoning_mode"):
+            underlying_name = str(model_config.get("name", "")).lower()
+            if "gpt-5.6" in underlying_name:
+                return True
 
         # Get supported_settings list, default to supporting common settings
         supported_settings = model_config.get("supported_settings")

{code_puppy-0.0.652 → code_puppy-0.0.653}/code_puppy/i18n/locales/en-US.json

@@ -109,5 +109,17 @@
   "cfg.colors.all_available": "\ud83c\udfa8 All Available Rich Colors:",
   "cfg.colors.usage": "Usage: /diff {{color_type}} <color_name>",
   "cfg.colors.white_text_note": "All diffs use white text on your chosen background colors",
-  "cfg.colors.hex_note": "You can also use hex colors like #ff0000 or rgb(255,0,0)"
+  "cfg.colors.hex_note": "You can also use hex colors like #ff0000 or rgb(255,0,0)",
+  "codex.imagegen.prompt_required": "A prompt is required.",
+  "codex.imagegen.auth_required": "Codex OAuth authentication is required. Run /codex-auth first.",
+  "codex.imagegen.request_failed": "Codex image generation request failed{detail}",
+  "codex.imagegen.invalid_json": "Codex image generation returned invalid JSON.",
+  "codex.imagegen.invalid_response": "Codex image generation returned an invalid response.",
+  "codex.imagegen.no_data": "Codex image generation returned no image data.",
+  "codex.imagegen.malformed_data": "Codex image generation returned malformed image data.",
+  "codex.imagegen.save_failed": "Could not save the generated image.",
+  "codex.imagegen.usage": "Usage: /codex-imagegen <prompt>",
+  "codex.imagegen.generating": "Generating image with Codex OAuth...",
+  "codex.imagegen.saved": "Generated image saved to {path}",
+  "codex.logout.reload_failed": "ChatGPT logout: agent reload failed: {error}"
 }

{code_puppy-0.0.652 → code_puppy-0.0.653}/code_puppy/model_factory.py

@@ -311,6 +311,26 @@ def make_model_settings(
             )
             if "codex" not in model_name:
                 model_settings_dict["openai_text_verbosity"] = get_openai_verbosity()
+
+            underlying_name = str(model_config.get("name", "")).lower()
+            is_gpt_5_6 = "gpt-5.6" in model_name.lower() or "gpt-5.6" in underlying_name
+            if is_gpt_5_6:
+                # pydantic-ai 1.56 does not expose context/mode settings yet,
+                # although the OpenAI SDK does. Supply the complete reasoning
+                # object through extra_body; a partial object would overwrite
+                # pydantic-ai's generated effort/summary payload.
+                reasoning = {
+                    "effort": model_settings_dict.pop("openai_reasoning_effort"),
+                    "summary": model_settings_dict.pop("openai_reasoning_summary"),
+                    "context": effective_settings.get("reasoning_context", "all_turns"),
+                    "mode": effective_settings.get("reasoning_mode", "standard"),
+                }
+                extra_body = dict(model_settings_dict.get("extra_body") or {})
+                extra_body["reasoning"] = reasoning
+                model_settings_dict["extra_body"] = extra_body
+                model_settings_dict.pop("reasoning_context", None)
+                model_settings_dict.pop("reasoning_mode", None)
+
             model_settings = OpenAIResponsesModelSettings(**model_settings_dict)
         else:
             # Chat Completions models don't support configurable reasoning summaries.

code_puppy-0.0.653/code_puppy/plugins/chatgpt_oauth/IMAGEGEN_SKILL.md

@@ -0,0 +1,44 @@
+---
+name: codex-imagegen
+description: Generate raster images with gpt-image-2 through Codex OAuth. Activate when the user asks to create a photo, illustration, icon, sprite, texture, product image, banner, or other raster artwork.
+version: "1.0"
+author: code-puppy
+---
+
+# Codex Image Generation
+
+Use the `codex_imagegen` tool when the user asks you to create raster artwork.
+The tool uses `gpt-image-2` through the user's existing Codex OAuth session,
+saves the resulting PNG, and displays it inline when iTerm2 supports doing so.
+
+## Decision rules
+
+1. Generate an image when creation of a photo, illustration, icon, sprite,
+   texture, product image, banner, concept art, or similar raster asset is an
+   explicit part of the user's request.
+2. Do not generate an image merely because one might decorate an otherwise
+   unrelated answer.
+3. Prefer ordinary code tools for diagrams that should remain editable as
+   source, such as Mermaid, SVG, charts, or HTML/CSS layouts.
+4. Before calling the tool, turn the user's request into a complete standalone
+   visual prompt. Include subject, composition, style, lighting, colors,
+   perspective, mood, and important exclusions when those details are known.
+5. Do not claim that generation succeeded until the tool returns `success: true`.
+6. Report the saved path after success. The image may already be visible inline,
+   so do not redundantly embed it unless the user asks.
+7. If authentication is missing, tell the user to run `/codex-auth`.
+
+## Tool
+
+Call:
+
+```text
+codex_imagegen(prompt="A complete standalone image prompt")
+```
+
+The result contains:
+
+- `success`: whether generation completed
+- `path`: saved PNG path on success
+- `displayed_inline`: whether iTerm2 inline display was attempted successfully
+- `error`: safe failure text when generation fails

code_puppy-0.0.653/code_puppy/plugins/chatgpt_oauth/image_generation.py

@@ -0,0 +1,161 @@
+"""Image generation through the ChatGPT Codex OAuth backend."""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+import sys
+import uuid
+from pathlib import Path
+from typing import Any
+
+import requests
+
+from code_puppy import config
+from code_puppy.i18n import t
+
+from .config import CHATGPT_OAUTH_CONFIG
+from .utils import get_valid_access_token, load_stored_tokens
+
+_IMAGE_MODEL = "gpt-image-2"
+_REQUEST_TIMEOUT_SECONDS = 180
+
+
+class CodexImageGenerationError(RuntimeError):
+    """A safe, user-displayable image generation failure."""
+
+
+def generate_image(prompt: str) -> Path:
+    """Generate one image with Codex OAuth and save it under Code Puppy data."""
+    normalized_prompt = prompt.strip()
+    if not normalized_prompt:
+        raise CodexImageGenerationError(t("codex.imagegen.prompt_required"))
+
+    access_token = get_valid_access_token()
+    tokens = load_stored_tokens() or {}
+    account_id = str(tokens.get("account_id", "")).strip()
+    if not access_token or not account_id:
+        raise CodexImageGenerationError(t("codex.imagegen.auth_required"))
+
+    response = _post_generation_request(access_token, account_id, normalized_prompt)
+    image_bytes = _decode_first_image(response)
+    return _save_image(image_bytes)
+
+
+def _post_generation_request(
+    access_token: str, account_id: str, prompt: str
+) -> dict[str, Any]:
+    base_url = str(CHATGPT_OAUTH_CONFIG["api_base_url"]).rstrip("/")
+    headers = {
+        "Authorization": f"Bearer {access_token}",
+        "ChatGPT-Account-Id": account_id,
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "originator": CHATGPT_OAUTH_CONFIG.get("originator", "codex_cli_rs"),
+        "User-Agent": (
+            f"{CHATGPT_OAUTH_CONFIG.get('originator', 'codex_cli_rs')}/"
+            f"{CHATGPT_OAUTH_CONFIG.get('client_version', 'unknown')}"
+        ),
+    }
+    payload = {
+        "prompt": prompt,
+        "background": "auto",
+        "model": _IMAGE_MODEL,
+        "quality": "auto",
+        "size": "auto",
+    }
+
+    try:
+        response = requests.post(
+            f"{base_url}/images/generations",
+            headers=headers,
+            json=payload,
+            timeout=_REQUEST_TIMEOUT_SECONDS,
+        )
+        response.raise_for_status()
+        body = response.json()
+    except requests.RequestException as exc:
+        detail = _response_error_detail(getattr(exc, "response", None))
+        suffix = f": {detail}" if detail else ""
+        raise CodexImageGenerationError(
+            t("codex.imagegen.request_failed", detail=suffix)
+        ) from exc
+    except ValueError as exc:
+        raise CodexImageGenerationError(t("codex.imagegen.invalid_json")) from exc
+
+    if not isinstance(body, dict):
+        raise CodexImageGenerationError(t("codex.imagegen.invalid_response"))
+    return body
+
+
+def _response_error_detail(response: requests.Response | None) -> str:
+    if response is None:
+        return ""
+    try:
+        body = response.json()
+    except ValueError:
+        return response.text.strip()[:300]
+    if not isinstance(body, dict):
+        return ""
+    error = body.get("error")
+    if isinstance(error, dict):
+        return str(error.get("message", ""))[:300]
+    return str(error or body.get("detail", ""))[:300]
+
+
+def _decode_first_image(body: dict[str, Any]) -> bytes:
+    data = body.get("data")
+    encoded = data[0].get("b64_json") if isinstance(data, list) and data else None
+    if not isinstance(encoded, str) or not encoded:
+        raise CodexImageGenerationError(t("codex.imagegen.no_data"))
+    try:
+        return base64.b64decode(encoded, validate=True)
+    except (binascii.Error, ValueError) as exc:
+        raise CodexImageGenerationError(t("codex.imagegen.malformed_data")) from exc
+
+
+def emit_iterm_image(output_path: Path) -> bool:
+    """Display a saved image with iTerm2's OSC 1337 inline-image protocol."""
+    if not _is_iterm2() or not sys.stdout.isatty():
+        return False
+
+    try:
+        image_data = base64.b64encode(output_path.read_bytes()).decode("ascii")
+        encoded_name = base64.b64encode(output_path.name.encode()).decode("ascii")
+        sequence = (
+            f"\033]1337;File=name={encoded_name};inline=1;"
+            f"preserveAspectRatio=1:{image_data}\a\n"
+        )
+        from code_puppy.messaging.run_ui import suspended_run_ui
+
+        with suspended_run_ui():
+            sys.stdout.write(sequence)
+            sys.stdout.flush()
+    except Exception:
+        # Inline display is best-effort; the image remains safely saved even if
+        # terminal detection lied or the active UI cannot be suspended.
+        return False
+    return True
+
+
+def _is_iterm2() -> bool:
+    return bool(
+        os.environ.get("ITERM_SESSION_ID")
+        or os.environ.get("TERM_PROGRAM", "").lower() == "iterm.app"
+    )
+
+
+def _save_image(image_bytes: bytes) -> Path:
+    output_dir = Path(config.DATA_DIR) / "generated_images"
+    output_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
+    output_path = output_dir / f"codex-{uuid.uuid4().hex}.png"
+    temporary_path = output_path.with_suffix(".tmp")
+    try:
+        temporary_path.write_bytes(image_bytes)
+        os.chmod(temporary_path, 0o600)
+        temporary_path.replace(output_path)
+    except OSError as exc:
+        temporary_path.unlink(missing_ok=True)
+        raise CodexImageGenerationError(t("codex.imagegen.save_failed")) from exc
+    return output_path

code_puppy-0.0.653/code_puppy/plugins/chatgpt_oauth/image_tool.py

@@ -0,0 +1,50 @@
+"""Agent-facing Codex OAuth image-generation tool."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from pydantic_ai import RunContext
+
+from .image_generation import (
+    CodexImageGenerationError,
+    emit_iterm_image,
+    generate_image,
+)
+
+TOOL_NAME = "codex_imagegen"
+
+
+def register_codex_imagegen(agent: Any) -> None:
+    """Register image generation on a pydantic-ai agent."""
+
+    @agent.tool
+    async def codex_imagegen(context: RunContext, prompt: str) -> dict[str, Any]:
+        """Generate a raster image using gpt-image-2 and Codex OAuth.
+
+        Use this when the user asks you to create a photo, illustration, icon,
+        sprite, texture, product image, banner, or other raster artwork. Write a
+        complete standalone visual prompt because the image model does not see
+        the conversation. The PNG is saved automatically and displayed inline
+        in iTerm2 when supported.
+
+        Args:
+            prompt: Detailed standalone description of the image to generate.
+        """
+        del context
+        try:
+            output_path = await asyncio.to_thread(generate_image, prompt)
+        except CodexImageGenerationError as exc:
+            return {"success": False, "error": str(exc)}
+
+        displayed_inline = emit_iterm_image(output_path)
+        return {
+            "success": True,
+            "path": str(output_path),
+            "displayed_inline": displayed_inline,
+        }
+
+
+def register_tools_callback() -> list[dict[str, Any]]:
+    return [{"name": TOOL_NAME, "register_func": register_codex_imagegen}]

{code_puppy-0.0.652 → code_puppy-0.0.653}/code_puppy/plugins/chatgpt_oauth/register_callbacks.py

@@ -7,10 +7,12 @@ the 'chatgpt_oauth' model type handler.
 from __future__ import annotations
 
 import os
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
-from code_puppy.messaging import emit_info, emit_success, emit_warning
+from code_puppy.i18n import t
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 from code_puppy.model_switching import set_model_and_reload_agent
 
 from .config import CHATGPT_OAUTH_CONFIG, get_token_storage_path
@@ -38,6 +40,7 @@ def _custom_help() -> List[Tuple[str, str]]:
         ("codex-status", "Alias for /chatgpt-status"),
         ("chatgpt-logout", "Remove ChatGPT OAuth tokens and imported models"),
         ("codex-logout", "Alias for /chatgpt-logout"),
+        ("codex-imagegen <prompt>", "Generate an image with Codex OAuth"),
     ]
 
 
@@ -68,6 +71,8 @@ def _handle_chatgpt_status() -> None:
 
 
 def _handle_chatgpt_logout() -> None:
+    was_authenticated = _is_codex_oauth_authenticated()
+
     token_path = get_token_storage_path()
     if token_path.exists():
         token_path.unlink()
@@ -82,6 +87,36 @@ def _handle_chatgpt_logout() -> None:
 
     emit_success("ChatGPT logout complete")
 
+    if was_authenticated:
+        _reload_active_agent()
+
+
+def _is_codex_oauth_authenticated() -> bool:
+    """Whether Codex OAuth tokens are present on disk."""
+    tokens = load_stored_tokens()
+    return bool(tokens and tokens.get("access_token") and tokens.get("account_id"))
+
+
+def _reload_active_agent() -> None:
+    """Reload the active agent so tool advertisement changes take effect."""
+    from code_puppy.agents import get_current_agent
+
+    try:
+        current_agent = get_current_agent()
+    except Exception:
+        return
+    if current_agent is None:
+        return
+    try:
+        if hasattr(current_agent, "refresh_config"):
+            try:
+                current_agent.refresh_config()
+            except Exception:
+                pass
+        current_agent.reload_code_generation_agent()
+    except Exception as exc:
+        emit_warning(t("codex.logout.reload_failed", error=str(exc)))
+
 
 def _handle_custom_command(command: str, name: str) -> Optional[bool]:
     if not name:
@@ -100,6 +135,27 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
         _handle_chatgpt_logout()
         return True
 
+    if name == "codex-imagegen":
+        from .image_generation import (
+            CodexImageGenerationError,
+            emit_iterm_image,
+            generate_image,
+        )
+
+        _, _, prompt = command.partition(" ")
+        if not prompt.strip():
+            emit_warning(t("codex.imagegen.usage"))
+            return True
+        emit_info(t("codex.imagegen.generating"))
+        try:
+            output_path = generate_image(prompt)
+        except CodexImageGenerationError as exc:
+            emit_error(str(exc))
+        else:
+            emit_success(t("codex.imagegen.saved", path=str(output_path)))
+            emit_iterm_image(output_path)
+        return True
+
     return None
 
 
@@ -171,6 +227,28 @@ def _create_chatgpt_oauth_model(
     return OpenAIResponsesModel(model_name=model_config["name"], provider=provider)
 
 
+def _register_imagegen_skill() -> list[dict[str, str]]:
+    return [
+        {
+            "name": "codex-imagegen",
+            "skill_md_path": str(Path(__file__).with_name("IMAGEGEN_SKILL.md")),
+        }
+    ]
+
+
+def _register_imagegen_tools() -> list[dict[str, Any]]:
+    from .image_tool import register_tools_callback
+
+    return register_tools_callback()
+
+
+def _advertise_imagegen_tool(agent_name: str | None = None) -> list[str]:
+    del agent_name
+    if not _is_codex_oauth_authenticated():
+        return []
+    return ["codex_imagegen"]
+
+
 def _register_model_types() -> List[Dict[str, Any]]:
     """Register the chatgpt_oauth model type handler."""
     return [{"type": "chatgpt_oauth", "handler": _create_chatgpt_oauth_model}]
@@ -192,4 +270,7 @@ def _refresh_usage_on_agent_run(
 register_callback("custom_command_help", _custom_help)
 register_callback("custom_command", _handle_custom_command)
 register_callback("register_model_type", _register_model_types)
+register_callback("register_skills", _register_imagegen_skill)
+register_callback("register_tools", _register_imagegen_tools)
+register_callback("register_agent_tools", _advertise_imagegen_tool)
 register_callback("agent_run_start", _refresh_usage_on_agent_run)