code-puppy 0.0.373__py3-none-any.whl → 0.0.375__py3-none-any.whl

code_puppy/config.py

@@ -101,6 +101,9 @@ PACK_AGENT_NAMES = frozenset(
     ]
 )
 
+# Agents that require Universal Constructor to be enabled
+UC_AGENT_NAMES = frozenset(["helios"])
+
 
 def get_pack_agents_enabled() -> bool:
     """Return True if pack agents are enabled (default False).
@@ -117,6 +120,30 @@ def get_pack_agents_enabled() -> bool:
     return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
 
 
+def get_universal_constructor_enabled() -> bool:
+    """Return True if the Universal Constructor is enabled (default True).
+
+    The Universal Constructor allows agents to dynamically create, manage,
+    and execute custom tools at runtime. When enabled, agents can extend
+    their capabilities by writing Python code that becomes callable tools.
+
+    When False, the universal_constructor tool is not registered with agents.
+    """
+    cfg_val = get_value("enable_universal_constructor")
+    if cfg_val is None:
+        return True  # Enabled by default
+    return str(cfg_val).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def set_universal_constructor_enabled(enabled: bool) -> None:
+    """Enable or disable the Universal Constructor.
+
+    Args:
+        enabled: True to enable, False to disable
+    """
+    set_value("enable_universal_constructor", "true" if enabled else "false")
+
+
 DEFAULT_SECTION = "puppy"
 REQUIRED_KEYS = ["puppy_name", "owner_name"]
 
@@ -260,6 +287,8 @@ def get_config_keys():
     default_keys.append("enable_dbos")
     # Add pack agents control key
     default_keys.append("enable_pack_agents")
+    # Add universal constructor control key
+    default_keys.append("enable_universal_constructor")
     # Add cancel agent key configuration
     default_keys.append("cancel_agent_key")
     # Add banner color keys

code_puppy/messaging/messages.py

@@ -317,6 +317,21 @@ class SubAgentStatusMessage(BaseMessage):
     )
 
 
+class UniversalConstructorMessage(BaseMessage):
+    """Result of a universal_constructor operation."""
+
+    category: MessageCategory = MessageCategory.TOOL_OUTPUT
+    action: str = Field(
+        description="The UC action performed (list/call/create/update/info)"
+    )
+    tool_name: Optional[str] = Field(
+        default=None, description="Tool name if applicable"
+    )
+    success: bool = Field(description="Whether the operation succeeded")
+    summary: str = Field(description="Brief summary of the result")
+    details: Optional[str] = Field(default=None, description="Additional details")
+
+
 # =============================================================================
 # User Interaction Messages (Agent → User)
 # =============================================================================
@@ -443,6 +458,7 @@ AnyMessage = Union[
     SubAgentInvocationMessage,
     SubAgentResponseMessage,
     SubAgentStatusMessage,
+    UniversalConstructorMessage,
     UserInputRequest,
     ConfirmationRequest,
     SelectionRequest,
@@ -485,6 +501,8 @@ __all__ = [
     "SubAgentInvocationMessage",
     "SubAgentResponseMessage",
     "SubAgentStatusMessage",
+    # Universal Constructor
+    "UniversalConstructorMessage",
     # User interaction
     "UserInputRequest",
     "ConfirmationRequest",

code_puppy/messaging/rich_renderer.py

@@ -48,6 +48,7 @@ from .messages import (
     SubAgentInvocationMessage,
     SubAgentResponseMessage,
     TextMessage,
+    UniversalConstructorMessage,
     UserInputRequest,
     VersionCheckMessage,
 )
@@ -287,6 +288,8 @@ class RichConsoleRenderer:
         elif isinstance(message, SubAgentResponseMessage):
             # Skip rendering - we now display sub-agent responses via display_non_streamed_result
             pass
+        elif isinstance(message, UniversalConstructorMessage):
+            self._render_universal_constructor(message)
         elif isinstance(message, UserInputRequest):
             # Can't handle async user input in sync context - skip
             self._console.print("[dim]User input requested (requires async)[/dim]")
@@ -672,15 +675,21 @@ class RichConsoleRenderer:
             self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
 
     def _render_shell_line(self, msg: ShellLineMessage) -> None:
-        """Render shell output line preserving ANSI codes."""
-        from rich.text import Text
+        """Render shell output line preserving ANSI codes and carriage returns."""
+        import sys
 
-        # Use Text.from_ansi() to parse ANSI codes into Rich styling
-        # This preserves colors while still being safe
-        text = Text.from_ansi(msg.line)
+        from rich.text import Text
 
-        # Make all shell output dim to reduce visual noise
-        self._console.print(text, style="dim")
+        # Check if line contains carriage return (progress bar style output)
+        if "\r" in msg.line:
+            # Bypass Rich entirely - write directly to stdout so terminal interprets \r
+            # Apply dim styling manually via ANSI codes
+            sys.stdout.write(f"\033[2m{msg.line}\033[0m")
+            sys.stdout.flush()
+        else:
+            # Normal line: use Rich for nice formatting
+            text = Text.from_ansi(msg.line)
+            self._console.print(text, style="dim")
 
     def _render_shell_output(self, msg: ShellOutputMessage) -> None:
         """Render shell command output - just a trailing newline for spinner separation.
@@ -775,6 +784,38 @@ class RichConsoleRenderer:
             f"({msg.message_count} messages)[/dim]"
         )
 
+    def _render_universal_constructor(self, msg: UniversalConstructorMessage) -> None:
+        """Render universal_constructor tool output with banner."""
+        # Skip for sub-agents unless verbose mode
+        if self._should_suppress_subagent_output():
+            return
+
+        # Format banner
+        banner = self._format_banner("universal_constructor", "UNIVERSAL CONSTRUCTOR")
+
+        # Build the header line with action and optional tool name
+        # Escape user-controlled strings to prevent Rich markup injection
+        header_parts = [f"\n{banner} 🔧 [bold cyan]{msg.action.upper()}[/bold cyan]"]
+        if msg.tool_name:
+            safe_tool_name = escape_rich_markup(msg.tool_name)
+            header_parts.append(f" [dim]tool=[/dim][bold]{safe_tool_name}[/bold]")
+        self._console.print("".join(header_parts))
+
+        # Status indicator
+        safe_summary = escape_rich_markup(msg.summary) if msg.summary else ""
+        if msg.success:
+            self._console.print(f"[green]✓[/green] {safe_summary}")
+        else:
+            self._console.print(f"[red]✗[/red] {safe_summary}")
+
+        # Show details if present
+        if msg.details:
+            safe_details = escape_rich_markup(msg.details)
+            self._console.print(f"[dim]{safe_details}[/dim]")
+
+        # Trailing newline for spinner separation
+        self._console.print()
+
     # =========================================================================
     # User Interaction
     # =========================================================================

code_puppy/messaging/subagent_console.py

@@ -24,7 +24,6 @@ from rich.text import Text
 
 from code_puppy.messaging.messages import SubAgentStatusMessage
 
-
 # =============================================================================
 # Status Configuration
 # =============================================================================

code_puppy/model_factory.py

@@ -393,78 +393,9 @@ class ModelFactory:
 
             provider = AnthropicProvider(anthropic_client=anthropic_client)
             return AnthropicModel(model_name=model_config["name"], provider=provider)
-        elif model_type == "claude_code":
-            url, headers, verify, api_key = get_custom_config(model_config)
-            if model_config.get("oauth_source") == "claude-code-plugin":
-                try:
-                    from code_puppy.plugins.claude_code_oauth.utils import (
-                        get_valid_access_token,
-                    )
-
-                    refreshed_token = get_valid_access_token()
-                    if refreshed_token:
-                        api_key = refreshed_token
-                        custom_endpoint = model_config.get("custom_endpoint")
-                        if isinstance(custom_endpoint, dict):
-                            custom_endpoint["api_key"] = refreshed_token
-                except ImportError:
-                    pass
-            if not api_key:
-                emit_warning(
-                    f"API key is not set for Claude Code endpoint; skipping model '{model_config.get('name')}'."
-                )
-                return None
-
-            # Check if interleaved thinking is enabled (defaults to True for OAuth models)
-            from code_puppy.config import get_effective_model_settings
-
-            effective_settings = get_effective_model_settings(model_name)
-            interleaved_thinking = effective_settings.get("interleaved_thinking", True)
-
-            # Handle anthropic-beta header based on interleaved_thinking setting
-            if "anthropic-beta" in headers:
-                beta_parts = [p.strip() for p in headers["anthropic-beta"].split(",")]
-                if interleaved_thinking:
-                    # Ensure interleaved-thinking is in the header
-                    if "interleaved-thinking-2025-05-14" not in beta_parts:
-                        beta_parts.append("interleaved-thinking-2025-05-14")
-                else:
-                    # Remove interleaved-thinking from the header
-                    beta_parts = [
-                        p for p in beta_parts if "interleaved-thinking" not in p
-                    ]
-                headers["anthropic-beta"] = ",".join(beta_parts) if beta_parts else None
-                if headers.get("anthropic-beta") is None:
-                    del headers["anthropic-beta"]
-            elif interleaved_thinking:
-                # No existing beta header, add one for interleaved thinking
-                headers["anthropic-beta"] = "interleaved-thinking-2025-05-14"
-
-            # Use a dedicated client wrapper that injects cache_control on /v1/messages
-            if verify is None:
-                verify = get_cert_bundle_path()
-
-            http2_enabled = get_http2()
-
-            client = ClaudeCacheAsyncClient(
-                headers=headers,
-                verify=verify,
-                timeout=180,
-                http2=http2_enabled,
-            )
+        # NOTE: 'claude_code' model type is now handled by the claude_code_oauth plugin
+        # via the register_model_type callback. See plugins/claude_code_oauth/register_callbacks.py
 
-            anthropic_client = AsyncAnthropic(
-                base_url=url,
-                http_client=client,
-                auth_token=api_key,
-            )
-            # Ensure cache_control is injected at the Anthropic SDK layer too
-            # so we don't depend solely on httpx internals.
-            patch_anthropic_client_messages(anthropic_client)
-            anthropic_client.api_key = None
-            anthropic_client.auth_token = api_key
-            provider = AnthropicProvider(anthropic_client=anthropic_client)
-            return AnthropicModel(model_name=model_config["name"], provider=provider)
         elif model_type == "azure_openai":
             azure_endpoint_config = model_config.get("azure_endpoint")
             if not azure_endpoint_config:
@@ -571,7 +502,42 @@ class ModelFactory:
             )
             setattr(zai_model, "provider", provider)
             return zai_model
+        # NOTE: 'antigravity' model type is now handled by the antigravity_oauth plugin
+        # via the register_model_type callback. See plugins/antigravity_oauth/register_callbacks.py
+
         elif model_type == "custom_gemini":
+            # Backwards compatibility: delegate to antigravity plugin if antigravity flag is set
+            # New configs use type="antigravity" directly, but old configs may have
+            # type="custom_gemini" with antigravity=True
+            if model_config.get("antigravity"):
+                # Find and call the antigravity handler from the plugin
+                registered_handlers = callbacks.on_register_model_types()
+                for handler_info in registered_handlers:
+                    handlers = (
+                        handler_info
+                        if isinstance(handler_info, list)
+                        else [handler_info]
+                        if handler_info
+                        else []
+                    )
+                    for handler_entry in handlers:
+                        if (
+                            isinstance(handler_entry, dict)
+                            and handler_entry.get("type") == "antigravity"
+                        ):
+                            handler = handler_entry.get("handler")
+                            if callable(handler):
+                                try:
+                                    return handler(model_name, model_config, config)
+                                except Exception as e:
+                                    logger.error(f"Antigravity handler failed: {e}")
+                                    return None
+                # If no antigravity handler found, warn and fall through
+                emit_warning(
+                    f"Model '{model_config.get('name')}' has antigravity=True but antigravity plugin not loaded."
+                )
+                return None
+
             url, headers, verify, api_key = get_custom_config(model_config)
             if not api_key:
                 emit_warning(
@@ -579,114 +545,7 @@ class ModelFactory:
                 )
                 return None
 
-            # Check if this is an Antigravity model
-            if model_config.get("antigravity"):
-                try:
-                    from code_puppy.plugins.antigravity_oauth.token import (
-                        is_token_expired,
-                        refresh_access_token,
-                    )
-                    from code_puppy.plugins.antigravity_oauth.transport import (
-                        create_antigravity_client,
-                    )
-                    from code_puppy.plugins.antigravity_oauth.utils import (
-                        load_stored_tokens,
-                        save_tokens,
-                    )
-
-                    # Try to import custom model for thinking signatures
-                    try:
-                        from code_puppy.plugins.antigravity_oauth.antigravity_model import (
-                            AntigravityModel,
-                        )
-                    except ImportError:
-                        AntigravityModel = None
-
-                    # Get fresh access token (refresh if needed)
-                    tokens = load_stored_tokens()
-                    if not tokens:
-                        emit_warning(
-                            "Antigravity tokens not found; run /antigravity-auth first."
-                        )
-                        return None
-
-                    access_token = tokens.get("access_token", "")
-                    refresh_token = tokens.get("refresh_token", "")
-                    expires_at = tokens.get("expires_at")
-
-                    # Refresh if expired or about to expire (initial check)
-                    if is_token_expired(expires_at):
-                        new_tokens = refresh_access_token(refresh_token)
-                        if new_tokens:
-                            access_token = new_tokens.access_token
-                            refresh_token = new_tokens.refresh_token
-                            expires_at = new_tokens.expires_at
-                            tokens["access_token"] = new_tokens.access_token
-                            tokens["refresh_token"] = new_tokens.refresh_token
-                            tokens["expires_at"] = new_tokens.expires_at
-                            save_tokens(tokens)
-                        else:
-                            emit_warning(
-                                "Failed to refresh Antigravity token; run /antigravity-auth again."
-                            )
-                            return None
-
-                    # Callback to persist tokens when proactively refreshed during session
-                    def on_token_refreshed(new_tokens):
-                        """Persist new tokens when proactively refreshed."""
-                        try:
-                            updated_tokens = load_stored_tokens() or {}
-                            updated_tokens["access_token"] = new_tokens.access_token
-                            updated_tokens["refresh_token"] = new_tokens.refresh_token
-                            updated_tokens["expires_at"] = new_tokens.expires_at
-                            save_tokens(updated_tokens)
-                            logger.debug(
-                                "Persisted proactively refreshed Antigravity tokens"
-                            )
-                        except Exception as e:
-                            logger.warning("Failed to persist refreshed tokens: %s", e)
-
-                    project_id = tokens.get(
-                        "project_id", model_config.get("project_id", "")
-                    )
-                    client = create_antigravity_client(
-                        access_token=access_token,
-                        project_id=project_id,
-                        model_name=model_config["name"],
-                        base_url=url,
-                        headers=headers,
-                        refresh_token=refresh_token,
-                        expires_at=expires_at,
-                        on_token_refreshed=on_token_refreshed,
-                    )
-
-                    # Use custom model with direct httpx client
-                    if AntigravityModel:
-                        model = AntigravityModel(
-                            model_name=model_config["name"],
-                            api_key=api_key
-                            or "",  # Antigravity uses OAuth, key may be empty
-                            base_url=url,
-                            http_client=client,
-                        )
-                    else:
-                        model = GeminiModel(
-                            model_name=model_config["name"],
-                            api_key=api_key or "",
-                            base_url=url,
-                            http_client=client,
-                        )
-
-                    return model
-
-                except ImportError:
-                    emit_warning(
-                        f"Antigravity transport not available; skipping model '{model_config.get('name')}'."
-                    )
-                    return None
-            else:
-                client = create_async_client(headers=headers, verify=verify)
-
+            client = create_async_client(headers=headers, verify=verify)
             model = GeminiModel(
                 model_name=model_config["name"],
                 api_key=api_key,
@@ -814,85 +673,8 @@ class ModelFactory:
             )
             return model
 
-        elif model_type == "chatgpt_oauth":
-            # ChatGPT OAuth models use the Codex API at chatgpt.com
-            try:
-                try:
-                    from chatgpt_oauth.config import CHATGPT_OAUTH_CONFIG
-                    from chatgpt_oauth.utils import (
-                        get_valid_access_token,
-                        load_stored_tokens,
-                    )
-                except ImportError:
-                    from code_puppy.plugins.chatgpt_oauth.config import (
-                        CHATGPT_OAUTH_CONFIG,
-                    )
-                    from code_puppy.plugins.chatgpt_oauth.utils import (
-                        get_valid_access_token,
-                        load_stored_tokens,
-                    )
-            except ImportError as exc:
-                emit_warning(
-                    f"ChatGPT OAuth plugin not available; skipping model '{model_config.get('name')}'. "
-                    f"Error: {exc}"
-                )
-                return None
-
-            # Get a valid access token (refreshing if needed)
-            access_token = get_valid_access_token()
-            if not access_token:
-                emit_warning(
-                    f"Failed to get valid ChatGPT OAuth token; skipping model '{model_config.get('name')}'. "
-                    "Run /chatgpt-auth to authenticate."
-                )
-                return None
-
-            # Get account_id from stored tokens (required for ChatGPT-Account-Id header)
-            tokens = load_stored_tokens()
-            account_id = tokens.get("account_id", "") if tokens else ""
-            if not account_id:
-                emit_warning(
-                    f"No account_id found in ChatGPT OAuth tokens; skipping model '{model_config.get('name')}'. "
-                    "Run /chatgpt-auth to re-authenticate."
-                )
-                return None
-
-            # Build headers for ChatGPT Codex API
-            originator = CHATGPT_OAUTH_CONFIG.get("originator", "codex_cli_rs")
-            client_version = CHATGPT_OAUTH_CONFIG.get("client_version", "0.72.0")
-
-            headers = {
-                "ChatGPT-Account-Id": account_id,
-                "originator": originator,
-                "User-Agent": f"{originator}/{client_version}",
-            }
-            # Merge with any headers from model config
-            config_headers = model_config.get("custom_endpoint", {}).get("headers", {})
-            headers.update(config_headers)
-
-            # Get base URL - Codex API uses chatgpt.com, not api.openai.com
-            base_url = model_config.get("custom_endpoint", {}).get(
-                "url", CHATGPT_OAUTH_CONFIG["api_base_url"]
-            )
-
-            # Create HTTP client with Codex interceptor for store=false injection
-            from code_puppy.chatgpt_codex_client import create_codex_async_client
-
-            verify = get_cert_bundle_path()
-            client = create_codex_async_client(headers=headers, verify=verify)
-
-            provider = OpenAIProvider(
-                api_key=access_token,
-                base_url=base_url,
-                http_client=client,
-            )
-
-            # ChatGPT Codex API only supports Responses format
-            model = OpenAIResponsesModel(
-                model_name=model_config["name"], provider=provider
-            )
-            setattr(model, "provider", provider)
-            return model
+        # NOTE: 'chatgpt_oauth' model type is now handled by the chatgpt_oauth plugin
+        # via the register_model_type callback. See plugins/chatgpt_oauth/register_callbacks.py
 
         elif model_type == "round_robin":
             # Get the list of model names to use in the round-robin
@@ -916,4 +698,27 @@ class ModelFactory:
             return RoundRobinModel(*models, rotate_every=rotate_every)
 
         else:
+            # Check for plugin-registered model type handlers
+            registered_handlers = callbacks.on_register_model_types()
+            for handler_info in registered_handlers:
+                # Handler info can be a list of dicts or a single dict
+                if isinstance(handler_info, list):
+                    handlers = handler_info
+                else:
+                    handlers = [handler_info] if handler_info else []
+
+                for handler_entry in handlers:
+                    if not isinstance(handler_entry, dict):
+                        continue
+                    if handler_entry.get("type") == model_type:
+                        handler = handler_entry.get("handler")
+                        if callable(handler):
+                            try:
+                                return handler(model_name, model_config, config)
+                            except Exception as e:
+                                logger.error(
+                                    f"Plugin handler for model type '{model_type}' failed: {e}"
+                                )
+                                return None
+
             raise ValueError(f"Unsupported model type: {model_type}")

code_puppy/model_utils.py

@@ -2,6 +2,9 @@
 
 This module centralizes logic for handling model-specific behaviors,
 particularly for claude-code and antigravity models which require special prompt handling.
+
+Plugins can register custom system prompt handlers via the 'get_model_system_prompt'
+callback to extend support for additional model types.
 """
 
 import pathlib
@@ -68,7 +71,36 @@ def prepare_prompt_for_model(
     user_prompt: str,
     prepend_system_to_user: bool = True,
 ) -> PreparedPrompt:
-    """Prepare instructions and prompt for a specific model."""
+    """Prepare instructions and prompt for a specific model.
+
+    This function handles model-specific system prompt requirements. Plugins can
+    register custom handlers via the 'get_model_system_prompt' callback to extend
+    support for additional model types.
+
+    Args:
+        model_name: The name of the model being used
+        system_prompt: The default system prompt from the agent
+        user_prompt: The user's prompt/message
+        prepend_system_to_user: Whether to prepend system prompt to user prompt
+            for models that require it (default: True)
+
+    Returns:
+        PreparedPrompt with instructions and user_prompt ready for the model.
+    """
+    # Check for plugin-registered system prompt handlers first
+    from code_puppy import callbacks
+
+    results = callbacks.on_get_model_system_prompt(
+        model_name, system_prompt, user_prompt
+    )
+    for result in results:
+        if result and isinstance(result, dict) and result.get("handled"):
+            return PreparedPrompt(
+                instructions=result.get("instructions", system_prompt),
+                user_prompt=result.get("user_prompt", user_prompt),
+                is_claude_code=result.get("is_claude_code", False),
+            )
+
     # Handle Claude Code models
     if is_claude_code_model(model_name):
         modified_prompt = user_prompt