code-puppy 0.0.655__tar.gz → 0.0.656__tar.gz

{code_puppy-0.0.655 → code_puppy-0.0.656}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.655
+Version: 0.0.656
 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.655 → code_puppy-0.0.656}/code_puppy/command_line/config_apply.py

@@ -17,6 +17,7 @@ from typing import Optional
 MODEL_SETTINGS_ONLY_KEYS = frozenset(
     {
         "openai_reasoning_effort",
+        "openai_reasoning_summary",
         "openai_verbosity",
     }
 )

{code_puppy-0.0.655 → code_puppy-0.0.656}/code_puppy/command_line/config_commands.py

@@ -38,9 +38,8 @@ def handle_show_command(command: str) -> bool:
         get_compaction_strategy,
         get_compaction_threshold,
         get_default_agent,
+        get_effective_model_settings,
         get_effective_temperature,
-        get_openai_reasoning_effort,
-        get_openai_verbosity,
         get_owner_name,
         get_protected_token_count,
         get_puppy_name,
@@ -63,6 +62,7 @@ def handle_show_command(command: str) -> bool:
     compaction_strategy = get_compaction_strategy()
     global_temperature = get_temperature()
     effective_temperature = get_effective_temperature(model)
+    model_settings = get_effective_model_settings(model)
 
     # Get current agent info
     current_agent = get_current_agent()
@@ -81,8 +81,8 @@ def handle_show_command(command: str) -> bool:
 [bold]compaction_threshold:[/bold]     [cyan]{compaction_threshold:.1%}[/cyan] context usage triggers compaction
 [bold]compaction_strategy:[/bold]   [cyan]{compaction_strategy}[/cyan] (summarization or truncation)
 [bold]resume_message_count:[/bold] [cyan]{get_resume_message_count()}[/cyan] messages shown on /resume
-[bold]reasoning_effort:[/bold]      [cyan]{get_openai_reasoning_effort()}[/cyan]
-[bold]verbosity:[/bold]             [cyan]{get_openai_verbosity()}[/cyan]
+[bold]reasoning_effort:[/bold]      [cyan]{model_settings.get("reasoning_effort", "(model default)")}[/cyan]
+[bold]verbosity:[/bold]             [cyan]{model_settings.get("verbosity", "(model default)")}[/cyan]
 [bold]temperature:[/bold]           [cyan]{effective_temperature if effective_temperature is not None else "(model default)"}[/cyan]{" (per-model)" if effective_temperature != global_temperature and effective_temperature is not None else ""}
 [bold]cancel_agent_key:[/bold]      [cyan]{get_cancel_agent_display_name()}[/cyan] (options: ctrl+c, ctrl+k, ctrl+q)
 

{code_puppy-0.0.655 → code_puppy-0.0.656}/code_puppy/command_line/model_settings_menu.py

@@ -23,16 +23,10 @@ from code_puppy.command_line.pagination import (
 from code_puppy.config import (
     get_all_model_settings,
     get_global_model_name,
-    get_openai_reasoning_effort,
-    get_openai_reasoning_summary,
-    get_openai_verbosity,
     get_value,
     model_supports_setting,
     reset_value,
     set_model_setting,
-    set_openai_reasoning_effort,
-    set_openai_reasoning_summary,
-    set_openai_verbosity,
     set_value,
 )
 from code_puppy.messaging import emit_info
@@ -276,20 +270,13 @@ def _write_per_model_retry(model_name: str, menu_key: str, value) -> None:
 
 
 def _get_model_display_settings(model_name: str) -> Dict:
-    """Get model settings merged with global OpenAI controls for display."""
+    """Get configured model settings plus model-specific display defaults."""
     settings = get_all_model_settings(model_name)
 
-    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"):
-        settings["verbosity"] = get_openai_verbosity()
-
     # Per-model retry overrides live in their own namespace, so inject their
     # current values here (only when actually set -- unset shows the default).
     for menu_key in _RETRY_MENU_KEYS:
@@ -692,14 +679,6 @@ class ModelSettingsMenu:
             lines.append(("class:tui.label", f"  {setting_def['name']}"))
             lines.append(("", "\n"))
 
-            # Show if this is a global setting
-            if setting_key in ("reasoning_effort", "verbosity"):
-                lines.append(
-                    (
-                        "class:tui.warning",
-                        "  ⚠ Global setting (applies to all GPT-5 models)",
-                    )
-                )
             lines.append(("", "\n\n"))
 
             # Description
@@ -864,17 +843,7 @@ class ModelSettingsMenu:
 
         setting_key = self.supported_settings[self.setting_index]
 
-        # Handle global OpenAI settings specially
-        if setting_key == "reasoning_effort":
-            if self.edit_value is not None:
-                set_openai_reasoning_effort(self.edit_value)
-        elif setting_key == "summary":
-            if self.edit_value is not None:
-                set_openai_reasoning_summary(self.edit_value)
-        elif setting_key == "verbosity":
-            if self.edit_value is not None:
-                set_openai_verbosity(self.edit_value)
-        elif setting_key in _RETRY_MENU_KEYS:
+        if setting_key in _RETRY_MENU_KEYS:
             # Per-model retry override -> dedicated retry_model_ namespace.
             _write_per_model_retry(self.selected_model, setting_key, self.edit_value)
         else:
@@ -907,17 +876,7 @@ class ModelSettingsMenu:
             # Reset edit value to default
             self.edit_value = _get_setting_default(setting_key, self.selected_model)
         else:
-            # Handle global OpenAI settings - reset to their defaults
-            if setting_key == "reasoning_effort":
-                set_openai_reasoning_effort("medium")  # Default
-                self.current_settings[setting_key] = "medium"
-            elif setting_key == "summary":
-                set_openai_reasoning_summary("auto")  # Default
-                self.current_settings[setting_key] = "auto"
-            elif setting_key == "verbosity":
-                set_openai_verbosity("medium")  # Default
-                self.current_settings[setting_key] = "medium"
-            elif setting_key in _RETRY_MENU_KEYS:
+            if setting_key in _RETRY_MENU_KEYS:
                 # Clear the per-model retry override -> falls back to global.
                 _write_per_model_retry(self.selected_model, setting_key, None)
                 if setting_key in self.current_settings:

{code_puppy-0.0.655 → code_puppy-0.0.656}/code_puppy/command_line/set_menu_catalog.py

@@ -43,7 +43,6 @@ from code_puppy.config import (
     get_mcp_disabled,
     get_mcp_unbound_warning_silenced,
     get_message_limit,
-    get_openai_reasoning_summary,
     get_output_level,
     get_owner_name,
     get_pack_agents_enabled,
@@ -265,21 +264,6 @@ _COMPACTION = SettingsCategory(
 )
 
 
-_OPENAI = SettingsCategory(
-    name="OpenAI",
-    settings=(
-        Setting(
-            key="openai_reasoning_summary",
-            display_name="Reasoning Summary",
-            description="Style of reasoning summary shown to the user.",
-            type_hint="choice",
-            valid_values=("auto", "concise", "detailed"),
-            effective_getter=get_openai_reasoning_summary,
-        ),
-    ),
-)
-
-
 _FEATURES = SettingsCategory(
     name="Features",
     settings=(
@@ -629,7 +613,6 @@ SETTINGS_CATEGORIES: Tuple[SettingsCategory, ...] = (
     _SESSION,
     _COMPACTION,
     _OUTPUT,
-    _OPENAI,
     _FEATURES,
     _MCP,
     _GOAL,

{code_puppy-0.0.655 → code_puppy-0.0.656}/code_puppy/config.py

@@ -5,7 +5,7 @@ import json
 import logging
 import os
 import pathlib
-from typing import Optional
+from typing import Any, Optional
 
 from code_puppy.session_storage import save_session
 
@@ -393,9 +393,6 @@ def get_config_keys():
         "summarization_model",
         "message_limit",
         "allow_recursion",
-        "openai_reasoning_effort",
-        "openai_reasoning_summary",
-        "openai_verbosity",
         "auto_save_session",
         "max_saved_sessions",
         "http2",
@@ -855,78 +852,6 @@ def set_puppy_token(token: str):
     set_config_value("puppy_token", token)
 
 
-def get_openai_reasoning_effort() -> str:
-    """Return the configured OpenAI reasoning effort."""
-    allowed_values = {"minimal", "low", "medium", "high", "xhigh", "ultra"}
-    configured = (get_value("openai_reasoning_effort") or "medium").strip().lower()
-    if configured not in allowed_values:
-        return "medium"
-    return configured
-
-
-def set_openai_reasoning_effort(value: str) -> None:
-    """Persist the OpenAI reasoning effort ensuring it remains within allowed values."""
-    allowed_values = {"minimal", "low", "medium", "high", "xhigh", "ultra"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid reasoning effort '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_reasoning_effort", normalized)
-
-
-def get_openai_reasoning_summary() -> str:
-    """Return the configured OpenAI reasoning summary mode.
-
-    Supported values:
-    - auto: let the provider decide the best summary style
-    - concise: shorter reasoning summaries
-    - detailed: fuller reasoning summaries
-    """
-    allowed_values = {"auto", "concise", "detailed"}
-    configured = (get_value("openai_reasoning_summary") or "detailed").strip().lower()
-    if configured not in allowed_values:
-        return "auto"
-    return configured
-
-
-def set_openai_reasoning_summary(value: str) -> None:
-    """Persist the OpenAI reasoning summary mode ensuring it remains valid."""
-    allowed_values = {"auto", "concise", "detailed"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid reasoning summary '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_reasoning_summary", normalized)
-
-
-def get_openai_verbosity() -> str:
-    """Return the configured OpenAI verbosity (low, medium, high).
-
-    Controls how concise vs. verbose the model's responses are:
-    - low: more concise responses
-    - medium: balanced (default)
-    - high: more verbose responses
-    """
-    allowed_values = {"low", "medium", "high"}
-    configured = (get_value("openai_verbosity") or "medium").strip().lower()
-    if configured not in allowed_values:
-        return "medium"
-    return configured
-
-
-def set_openai_verbosity(value: str) -> None:
-    """Persist the OpenAI verbosity ensuring it remains within allowed values."""
-    allowed_values = {"low", "medium", "high"}
-    normalized = (value or "").strip().lower()
-    if normalized not in allowed_values:
-        raise ValueError(
-            f"Invalid verbosity '{value}'. Allowed: {', '.join(sorted(allowed_values))}"
-        )
-    set_config_value("openai_verbosity", normalized)
-
-
 def get_temperature() -> Optional[float]:
     """Return the configured model temperature (0.0 to 2.0).
 
@@ -1001,13 +926,13 @@ def get_model_setting(
         return default
 
 
-def set_model_setting(model_name: str, setting: str, value: Optional[float]) -> None:
+def set_model_setting(model_name: str, setting: str, value: Any | None) -> None:
     """Set a specific setting for a model.
 
     Args:
         model_name: The model name (e.g., 'gpt-5', 'zai-glm-5.1-api')
-        setting: The setting name (e.g., 'temperature', 'seed')
-        value: The value to set, or None to clear
+        setting: The setting name (e.g., 'temperature', 'reasoning_effort')
+        value: The numeric, string, or boolean value to set, or None to clear
     """
     sanitized_name = _sanitize_model_name_for_key(model_name)
     key = f"model_settings_{sanitized_name}_{setting}"

{code_puppy-0.0.655 → code_puppy-0.0.656}/code_puppy/model_factory.py

@@ -171,9 +171,6 @@ def make_model_settings(
     """
     from code_puppy.config import (
         get_effective_model_settings,
-        get_openai_reasoning_effort,
-        get_openai_reasoning_summary,
-        get_openai_verbosity,
         model_supports_setting,
     )
 
@@ -293,7 +290,9 @@ def make_model_settings(
         model_settings = OpenAIChatModelSettings(**model_settings_dict)
 
     elif "gpt-5" in model_name:
-        model_settings_dict["openai_reasoning_effort"] = get_openai_reasoning_effort()
+        model_settings_dict["openai_reasoning_effort"] = effective_settings.get(
+            "reasoning_effort", "medium"
+        )
 
         uses_responses_api = (
             model_type == "chatgpt_oauth"
@@ -306,11 +305,13 @@ def make_model_settings(
         )
 
         if uses_responses_api:
-            model_settings_dict["openai_reasoning_summary"] = (
-                get_openai_reasoning_summary()
+            model_settings_dict["openai_reasoning_summary"] = effective_settings.get(
+                "summary", "auto"
             )
             if "codex" not in model_name:
-                model_settings_dict["openai_text_verbosity"] = get_openai_verbosity()
+                model_settings_dict["openai_text_verbosity"] = effective_settings.get(
+                    "verbosity", "medium"
+                )
 
             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
@@ -336,8 +337,9 @@ def make_model_settings(
             # Chat Completions models don't support configurable reasoning summaries.
             # Keep the old verbosity injection path for non-Responses GPT-5 models.
             if "codex" not in model_name:
-                verbosity = get_openai_verbosity()
-                model_settings_dict["extra_body"] = {"verbosity": verbosity}
+                model_settings_dict["extra_body"] = {
+                    "verbosity": effective_settings.get("verbosity", "medium")
+                }
             model_settings = OpenAIChatModelSettings(**model_settings_dict)
     elif _is_anthropic_model(model_name, model_config):
         # Handle Anthropic extended thinking settings

{code_puppy-0.0.655 → code_puppy-0.0.656}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.655"
+version = "0.0.656"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"