code-puppy-core-plugins 0.0.41__tar.gz → 0.0.43__tar.gz

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.41
+Version: 0.0.43
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/code_puppy_core_plugins/chatgpt_oauth/config.py

@@ -28,8 +28,13 @@ CHATGPT_OAUTH_CONFIG: Dict[str, Any] = {
     # backend serves — never the raw number (openai/codex#31860, #32806).
     "default_context_length": 258400,
     "api_key_env_var": "CHATGPT_OAUTH_API_KEY",
-    # Codex CLI version info (for User-Agent header)
-    "client_version": "0.144.1",
+    # Codex CLI version info (for User-Agent header AND the /models
+    # ``client_version`` query param). The catalog gates models on it:
+    # gpt-6-astra has ``minimal_client_version: 0.153.0``, so an older value
+    # here silently hides newer models. Bump when a new generation lands.
+    "client_version": "0.153.3",
+    # Model selected right after a successful OAuth login.
+    "default_model": "codex-gpt-6-astra",
     "originator": "codex_cli_rs",
 }
 

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/code_puppy_core_plugins/chatgpt_oauth/register_callbacks.py

@@ -129,7 +129,7 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
 
     if name in {"chatgpt-auth", "codex-auth"}:
         run_oauth_flow()
-        set_model_and_reload_agent("codex-gpt-5.6-sol")
+        set_model_and_reload_agent(CHATGPT_OAUTH_CONFIG["default_model"])
         # Auth just succeeded: re-discover the auth-gated codex-imagegen skill now
         # rather than waiting for the next process restart.
         refresh_skill_cache()
@@ -205,7 +205,7 @@ def _create_chatgpt_oauth_model(
 
     # Build headers for ChatGPT Codex API
     originator = CHATGPT_OAUTH_CONFIG.get("originator", "codex_cli_rs")
-    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.144.1")
+    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.153.3")
 
     headers = {
         "ChatGPT-Account-Id": account_id,

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/code_puppy_core_plugins/chatgpt_oauth/test_plugin.py

@@ -314,10 +314,47 @@ def test_auth_command_refreshes_skill_cache():
         )
 
     oauth_flow.assert_called_once_with()
-    set_model.assert_called_once_with("codex-gpt-5.6-sol")
+    set_model.assert_called_once_with("codex-gpt-6-astra")
     refresh_skills.assert_called_once_with()
 
 
+def test_default_model_is_in_fallback_catalog():
+    """A default that isn't in the fallback list would 404 when /models is down."""
+    from code_puppy_core_plugins.chatgpt_oauth.config import CHATGPT_OAUTH_CONFIG
+
+    default = CHATGPT_OAUTH_CONFIG["default_model"]
+    prefix = CHATGPT_OAUTH_CONFIG["prefix"]
+    assert default.startswith(prefix)
+    assert default[len(prefix) :] in utils.DEFAULT_CODEX_MODELS
+
+
+def test_client_version_meets_gpt6_minimum():
+    """gpt-6-astra carries minimal_client_version 0.153.0 in the catalog."""
+    from code_puppy_core_plugins.chatgpt_oauth.config import CHATGPT_OAUTH_CONFIG
+
+    version = tuple(int(p) for p in CHATGPT_OAUTH_CONFIG["client_version"].split("."))
+    assert version >= (0, 153, 0)
+
+
+@pytest.mark.parametrize(
+    "name,xhigh,max_effort,responses_controls",
+    [
+        ("gpt-6-astra", True, True, True),
+        ("gpt-6-astra-pro", True, True, True),
+        ("gpt-5.6-sol", True, True, True),
+        ("gpt-5.5", True, False, False),
+        ("gpt-5.4-mini", True, False, False),
+        ("gpt-5.3-codex-spark", True, False, False),
+        ("codex-auto-review", True, False, False),
+        ("gpt-4o", False, False, False),
+    ],
+)
+def test_reasoning_gates_by_gpt_generation(name, xhigh, max_effort, responses_controls):
+    assert utils._supports_xhigh_reasoning(name) is xhigh
+    assert utils._supports_max_reasoning(name) is max_effort
+    assert utils._supports_responses_reasoning_controls(name) is responses_controls
+
+
 def test_codex_imagegen_agent_tool(tmp_path):
     registered = {}
 
@@ -679,5 +716,18 @@ def test_add_models_to_chatgpt_config(tmp_path):
         assert loaded["codex-gpt-4o"]["context_length"] == 258400
 
 
+def test_gpt6_astra_entry_gets_full_reasoning_surface(tmp_path):
+    with patch.object(
+        utils, "get_chatgpt_models_path", return_value=tmp_path / "chatgpt_models.json"
+    ):
+        assert utils.add_models_to_extra_config(["gpt-6-astra"])
+        entry = utils.load_chatgpt_models()["codex-gpt-6-astra"]
+
+    assert entry["supports_xhigh_reasoning"] is True
+    assert entry["supports_max_reasoning"] is True
+    assert "reasoning_context" in entry["supported_settings"]
+    assert "reasoning_mode" in entry["supported_settings"]
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/code_puppy_core_plugins/chatgpt_oauth/utils.py

@@ -7,10 +7,11 @@ import datetime
 import hashlib
 import json
 import logging
+import re
 import secrets
 import time
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 from urllib.parse import parse_qs as urllib_parse_qs
 from urllib.parse import urlencode, urlparse
 
@@ -377,6 +378,7 @@ def exchange_code_for_tokens(
 # Models known to work with ChatGPT OAuth tokens (sourced from codex-rs CLI
 # and shell-scripts/codex-call.sh).
 DEFAULT_CODEX_MODELS = [
+    "gpt-6-astra",
     "gpt-5.6-sol",
     "gpt-5.6-terra",
     "gpt-5.6-luna",
@@ -399,17 +401,39 @@ CODEX_MODEL_CONTEXT_LENGTHS = {
 }
 
 
+_GPT_VERSION_RE = re.compile(r"^gpt-(\d+)(?:\.(\d+))?")
+
+
+def _gpt_version(model_name: str) -> Optional[Tuple[int, int]]:
+    """``(major, minor)`` for a ``gpt-X[.Y]...`` Codex slug, else ``None``.
+
+    Kept local (rather than importing ``code_puppy.model_utils``) so this
+    plugin doesn't hard-require a core release that ships the shared helper.
+    """
+    match = _GPT_VERSION_RE.match(model_name.lower())
+    if not match:
+        return None
+    return int(match.group(1)), int(match.group(2) or 0)
+
+
+def _gpt_at_least(model_name: str, minimum: Tuple[int, int]) -> bool:
+    version = _gpt_version(model_name)
+    return version is not None and version >= minimum
+
+
 def _supports_xhigh_reasoning(model_name: str) -> bool:
     """Return whether a ChatGPT OAuth model supports xhigh reasoning."""
-    normalized_model_name = model_name.lower()
-    return "codex" in normalized_model_name or normalized_model_name.startswith(
-        ("gpt-5.4", "gpt-5.5", "gpt-5.6")
-    )
+    return "codex" in model_name.lower() or _gpt_at_least(model_name, (5, 4))
 
 
 def _supports_max_reasoning(model_name: str) -> bool:
     """Return whether a ChatGPT OAuth model supports max reasoning effort."""
-    return model_name.lower().startswith("gpt-5.6")
+    return _gpt_at_least(model_name, (5, 6))
+
+
+def _supports_responses_reasoning_controls(model_name: str) -> bool:
+    """GPT-5.6+ (incl. GPT-6) expose reasoning_context / reasoning_mode."""
+    return _gpt_at_least(model_name, (5, 6))
 
 
 def fetch_chatgpt_models(access_token: str, account_id: str) -> List[CodexModelInfo]:
@@ -431,7 +455,7 @@ def fetch_chatgpt_models(access_token: str, account_id: str) -> List[CodexModelI
     import platform
 
     # Build the models URL with client version
-    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.144.1")
+    client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.153.3")
     base_url = CHATGPT_OAUTH_CONFIG["api_base_url"].rstrip("/")
     models_url = f"{base_url}/models"
 
@@ -525,7 +549,7 @@ def add_models_to_extra_config(models: List[Union[str, CodexModelInfo]]) -> bool
             # Responses-API models always support reasoning effort, summaries,
             # and text verbosity; per-model extras are added below.
             supported_settings = ["reasoning_effort", "summary", "verbosity"]
-            if model_name.lower().startswith("gpt-5.6"):
+            if _supports_responses_reasoning_controls(model_name):
                 supported_settings.extend(["reasoning_context", "reasoning_mode"])
 
             # xhigh: codex + GPT-5.4+; max: GPT-5.6+. Separate flags so a stronger

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/README.md

@@ -0,0 +1,47 @@
+# Configuration profiles
+
+Use different model/agent harness settings without having terminals overwrite
+each other's pins:
+
+```text
+/profile                  # keyboard menu: c creates, Enter activates
+/profile create web       # snapshot this process's current config
+/profile use web          # switch only this running process
+/profile list
+```
+
+```sh
+code-puppy --profile web
+code-puppy --profile default
+code-puppy                  # always the default profile
+```
+
+Named profiles store INI settings in
+`~/.code_puppy/profiles/<name>/puppy.cfg` (or under
+`$XDG_CONFIG_HOME/code_puppy/profiles` when configured). `default` keeps using
+the existing `puppy.cfg`; no global active-profile pointer is needed.
+A nonexistent CLI profile exits with status 2, rather than silently
+running the wrong harness. Names are lowercase letters/digits/underscores/
+hyphens, 1–64 characters, starting with a letter or digit.
+
+All `puppy.cfg` settings are snapshotted, including agent model pins, model
+settings, token limits and `/set` values. Changes persist within that profile.
+Two processes deliberately using the **same** profile still share its settings;
+use distinct names for independent harnesses. Switching rebuilds the current
+agent while retaining its conversation, rather than changing agent identity.
+
+Model catalogs, credentials, custom agent definitions, skills, MCP server files
+and conversation storage remain shared. Profiles do not restrict which agents
+a model may invoke. A profile is a settings preset, not a security sandbox.
+Provider API keys are stored once in the OS keyring, with the existing
+permission-hardened `secrets.json` fallback. Creating or selecting a profile
+migrates recognized legacy credentials from all profile configs, checking for
+conflicts before writing and removing legacy values only after verified storage.
+Conflicting values block the operation without choosing a winner. Reconcile the
+reported key in the legacy configs and shared store, then retry. Values are never
+included in the conflict message. Environment-only keys are not copied.
+Custom model API-key and secret-header environment references are recognized;
+unrelated arbitrary secrets cannot be inferred, so configs still need care.
+Data is INI, not executed Python. The plugin's `config.py` contains storage logic.
+
+No deletion or overwrite operation is exposed in this initial version.

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/__init__.py

@@ -0,0 +1 @@
+"""Process-local configuration profiles."""

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/config.py

@@ -0,0 +1,111 @@
+"""Profile persistence; ordinary INI data, never executable Python presets.
+
+The legacy config is the default profile. Selecting a profile only redirects
+this process's config I/O; there is deliberately no global 'active' pointer.
+"""
+
+from __future__ import annotations
+
+import io
+import re
+from pathlib import Path
+
+from code_puppy import config
+from code_puppy.atomic_io import atomic_write_bytes, path_lock
+from code_puppy.config_file import load_config
+from code_puppy.i18n import t
+
+_active = "default"
+_NAME = re.compile(r"[a-z0-9][a-z0-9_-]{0,63}\Z")
+_RESERVED = {"con", "prn", "aux", "nul"} | {
+    f"{prefix}{i}" for prefix in ("com", "lpt") for i in range(1, 10)
+}
+
+
+def validate_name(name: str) -> str:
+    if not _NAME.fullmatch(name) or name in _RESERVED:
+        raise ValueError(t("profiles.invalid_name"))
+    return name
+
+
+def profile_path(name: str) -> Path:
+    validate_name(name)
+    root = Path(config.CONFIG_DIR)
+    if name == "default":
+        return root / "puppy.cfg"
+    directory = root / "profiles" / name
+    # Do not follow profile aliases outside the profiles directory.
+    if (
+        (root / "profiles").is_symlink()
+        or directory.is_symlink()
+        or (directory / "puppy.cfg").is_symlink()
+    ):
+        raise ValueError(t("profiles.symlink"))
+    return directory / "puppy.cfg"
+
+
+def active_profile() -> str:
+    return _active
+
+
+def list_profiles() -> list[str]:
+    root = Path(config.CONFIG_DIR) / "profiles"
+    if not root.exists():
+        return ["default"]
+    return ["default"] + sorted(
+        p.name
+        for p in root.iterdir()
+        if p.name != "default"
+        and _NAME.fullmatch(p.name)
+        and not p.is_symlink()
+        and not (p / "puppy.cfg").is_symlink()
+        and (p / "puppy.cfg").is_file()
+    )
+
+
+def create_profile(name: str) -> None:
+    """Snapshot current settings without overwriting an existing profile."""
+    target = profile_path(name)
+    if name == "default":
+        raise ValueError(t("profiles.exists", name=name))
+    if target.exists():
+        raise ValueError(t("profiles.exists", name=name))
+    migrate_credentials()
+    snapshot = load_config(str(config.CONFIG_FILE))
+    from code_puppy.shared_credentials import is_credential_key
+
+    # A concurrently running older Puppy may have written a plaintext key
+    # after migration. Never duplicate it into the new profile.
+    for section in [snapshot.default_section, *snapshot.sections()]:
+        for key in list(snapshot[section]):
+            if is_credential_key(key):
+                snapshot[section].pop(key, None)
+    buffer = io.StringIO()
+    snapshot.write(buffer)
+    target.parent.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    target.parent.mkdir(mode=0o700, exist_ok=True)
+    with path_lock(str(target)):
+        if target.exists():
+            raise ValueError(t("profiles.exists", name=name))
+        atomic_write_bytes(str(target), buffer.getvalue().encode("utf-8"))
+
+
+def activate_profile(name: str) -> None:
+    """Select a config for this process; missing named profiles fail closed."""
+    global _active
+    target = profile_path(name)
+    if name != "default" and not target.is_file():
+        raise ValueError(t("profiles.missing", name=name))
+    # Validate accessibility before changing any runtime state.
+    load_config(str(target))
+    migrate_credentials()
+    config.CONFIG_FILE = str(target)
+    config.reset_session_model()
+    config.clear_model_cache()
+    _active = name
+
+
+def migrate_credentials() -> None:
+    from code_puppy.shared_credentials import migrate
+
+    migrate([str(profile_path(name)) for name in list_profiles()])

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/locales/en-US.json

@@ -0,0 +1,18 @@
+{
+  "profiles.title": "Configuration profiles (* active in this process)",
+  "profiles.cli_help": "Use a named configuration profile for this run (default: default)",
+  "profiles.help": "Create and switch isolated configuration profiles",
+  "profiles.invalid_name": "Use 1–64 lowercase letters, digits, underscores or hyphens; start with a letter or digit.",
+  "profiles.symlink": "Symlinked profiles are not supported.",
+  "profiles.exists": "Profile '{name}' already exists.",
+  "profiles.missing": "Profile '{name}' does not exist. Create it with /profile create {name}.",
+  "profiles.error": "Profile error: {detail}",
+  "profiles.created": "Created '{name}' from the current settings. Select it with Enter or /profile use {name}.",
+  "profiles.active": "Active profile: {name} (this process only).",
+  "profiles.list": "Active: {active}\nProfiles: {names}",
+  "profiles.usage": "/profile | /profile list | /profile create NAME | /profile use NAME",
+  "profiles.keys": "↑/↓ select · Enter activate · c create · Esc/q close",
+  "profiles.new_name": "New profile name: {name}",
+  "profiles.row": "{cursor} {active} {name}",
+  "profiles.no_tty": "The profile menu needs a terminal. Use /profile list, create NAME or use NAME instead."
+}

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/menu.py

@@ -0,0 +1,95 @@
+"""Small keyboard-driven profile picker with inline profile creation."""
+
+from code_puppy.i18n import t
+from code_puppy_core_plugins.termflow_tui import FragmentTUI, fragments_to_lines
+
+from . import config
+
+
+class ProfileMenu:
+    def __init__(self):
+        self.names = config.list_profiles()
+        self.index = (
+            self.names.index(config.active_profile())
+            if config.active_profile() in self.names
+            else 0
+        )
+        self.creating = False
+        self.name = ""
+        self.message = ""
+
+    def render(self):
+        fragments = [("class:tui.title", t("profiles.title") + "\n\n")]
+        # Keep the selection visible even with a large profile collection.
+        start = max(0, self.index - 5)
+        for index in range(start, min(len(self.names), start + 10)):
+            name = self.names[index]
+            label = t(
+                "profiles.row",
+                cursor=">" if index == self.index else " ",
+                name=name,
+                active="*" if name == config.active_profile() else " ",
+            )
+            fragments.append(
+                (
+                    "class:tui.selected" if index == self.index else "class:tui.text",
+                    label + "\n",
+                )
+            )
+        fragments.append(("class:tui.help", "\n" + t("profiles.keys") + "\n"))
+        if self.creating:
+            fragments.append(
+                ("class:tui.input", t("profiles.new_name", name=self.name) + "\n")
+            )
+        if self.message:
+            fragments.append(("class:tui.warning", self.message))
+        return fragments_to_lines(fragments)
+
+    def on_key(self, key):
+        if key in ("ctrl-c", "\x03", "\x1b", "escape"):
+            if self.creating:
+                self.creating = False
+                return False
+            return True
+        try:
+            if self.creating:
+                if key in ("\r", "\n", "enter"):
+                    config.create_profile(self.name)
+                    self.names = config.list_profiles()
+                    self.index = self.names.index(self.name)
+                    self.creating = False
+                    self.message = t("profiles.created", name=self.name)
+                elif key in ("\x7f", "\b", "backspace"):
+                    self.name = self.name[:-1]
+                elif (
+                    len(key) == 1
+                    and key.isascii()
+                    and key.isprintable()
+                    and len(self.name) < 64
+                ):
+                    self.name += key
+            elif key in ("up", "\x1b[A", "k"):
+                self.index = (self.index - 1) % len(self.names)
+            elif key in ("down", "\x1b[B", "j"):
+                self.index = (self.index + 1) % len(self.names)
+            elif key == "c":
+                self.creating, self.name, self.message = True, "", ""
+            elif key in ("\r", "\n", "enter"):
+                from .register_callbacks import switch_profile
+
+                switch_profile(self.names[self.index])
+                self.message = t("profiles.active", name=config.active_profile())
+            elif key == "q":
+                return True
+        except (OSError, ValueError, RuntimeError) as exc:
+            self.message = t("profiles.error", detail=str(exc))
+        return False
+
+
+def run_menu():
+    import sys
+
+    if not sys.stdin.isatty():
+        raise ValueError(t("profiles.no_tty"))
+    menu = ProfileMenu()
+    FragmentTUI(menu.render, menu.on_key).run()

code_puppy_core_plugins-0.0.43/code_puppy_core_plugins/profiles/register_callbacks.py

@@ -0,0 +1,88 @@
+"""CLI and slash-command entry points for configuration profiles."""
+
+from __future__ import annotations
+
+import shlex
+import sys
+from pathlib import Path
+
+from code_puppy.callbacks import register_callback
+from code_puppy.i18n import add_catalog_dir, t
+
+from . import config
+
+add_catalog_dir(Path(__file__).parent / "locales")
+
+
+def register_cli_args(parser):
+    parser.add_argument(
+        "--profile", metavar="NAME", default="default", help=t("profiles.cli_help")
+    )
+
+
+def handle_cli_args(args):
+    try:
+        config.activate_profile(getattr(args, "profile", "default"))
+    except (OSError, ValueError) as exc:
+        print(t("profiles.error", detail=str(exc)), file=sys.stderr)
+        return {"handled": True, "exit_code": 2}
+    return None
+
+
+def switch_profile(name):
+    """Rebuild the current agent so cached model settings cannot leak."""
+    from code_puppy.agents.agent_manager import (
+        get_current_agent_name,
+        set_current_agent,
+    )
+
+    previous = config.active_profile()
+    agent = get_current_agent_name()
+    config.activate_profile(name)
+    try:
+        set_current_agent(agent)
+    except Exception:
+        config.activate_profile(previous)
+        raise
+
+
+def custom_command(command, name):
+    if name != "profile":
+        return None
+    from code_puppy.messaging import emit_error, emit_info
+
+    try:
+        parts = shlex.split(command)[1:]
+        if not parts:
+            from .menu import run_menu
+
+            run_menu()
+        elif parts == ["list"]:
+            emit_info(
+                t(
+                    "profiles.list",
+                    active=config.active_profile(),
+                    names=", ".join(config.list_profiles()),
+                )
+            )
+        elif len(parts) == 2 and parts[0] == "create":
+            config.create_profile(parts[1])
+            emit_info(t("profiles.created", name=parts[1]))
+        elif len(parts) == 2 and parts[0] == "use":
+            switch_profile(parts[1])
+            emit_info(t("profiles.active", name=parts[1]))
+        else:
+            emit_info(t("profiles.usage"))
+    except (OSError, ValueError, RuntimeError) as exc:
+        emit_error(t("profiles.error", detail=str(exc)))
+    return True
+
+
+def custom_help():
+    return [("profile", t("profiles.help"))]
+
+
+register_callback("register_cli_args", register_cli_args)
+register_callback("handle_cli_args", handle_cli_args)
+register_callback("custom_command", custom_command)
+register_callback("custom_command_help", custom_help)

{code_puppy_core_plugins-0.0.41 → code_puppy_core_plugins-0.0.43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.41"
+version = "0.0.43"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"
@@ -69,6 +69,7 @@ ollama_setup = "code_puppy_core_plugins.ollama_setup.register_callbacks"
 openrouter_oauth = "code_puppy_core_plugins.openrouter_oauth.register_callbacks"
 plugin_list = "code_puppy_core_plugins.plugin_list.register_callbacks"
 pop_command = "code_puppy_core_plugins.pop_command.register_callbacks"
+profiles = "code_puppy_core_plugins.profiles.register_callbacks"
 prompt_newline = "code_puppy_core_plugins.prompt_newline.register_callbacks"
 prune = "code_puppy_core_plugins.prune.register_callbacks"
 puppy_kennel = "code_puppy_core_plugins.puppy_kennel.register_callbacks"