code-puppy 0.0.372__py3-none-any.whl → 0.0.374__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]")
@@ -775,6 +778,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/plugins/claude_code_oauth/README.md

@@ -52,7 +52,7 @@ The plugin ships with sensible defaults in `config.py`:
 ```python
 CLAUDE_CODE_OAUTH_CONFIG = {
     "auth_url": "https://claude.ai/oauth/authorize",
-    "token_url": "https://claude.ai/api/oauth/token",
+    "token_url": "https://console.anthropic.com/v1/oauth/token",
     "api_base_url": "https://api.anthropic.com",
     "client_id": "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
     "scope": "org:create_api_key user:profile user:inference",

code_puppy/plugins/claude_code_oauth/SETUP.md

@@ -37,7 +37,7 @@ Anthropic exposes a shared **public client** (`claude-cli`) for command-line too
 ```python
 CLAUDE_CODE_OAUTH_CONFIG = {
     "auth_url": "https://claude.ai/oauth/authorize",
-    "token_url": "https://claude.ai/api/oauth/token",
+    "token_url": "https://console.anthropic.com/v1/oauth/token",
     "api_base_url": "https://api.anthropic.com",
     "client_id": "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
     "scope": "org:create_api_key user:profile user:inference",

code_puppy/plugins/claude_code_oauth/utils.py

@@ -21,10 +21,10 @@ from .config import (
     get_token_storage_path,
 )
 
-# Proactive refresh buffer: refresh tokens 1 hour before expiration
-# This ensures smooth operation by refreshing during model requests,
-# well before the token actually expires
-TOKEN_REFRESH_BUFFER_SECONDS = 3600  # 1 hour
+# Proactive refresh buffer default (seconds). Actual buffer is dynamic
+# based on expires_in to avoid overly aggressive refreshes.
+TOKEN_REFRESH_BUFFER_SECONDS = 300
+MIN_REFRESH_BUFFER_SECONDS = 30
 
 logger = logging.getLogger(__name__)
 
@@ -146,15 +146,40 @@ def _calculate_expires_at(expires_in: Optional[float]) -> Optional[float]:
         return None
 
 
-def is_token_expired(tokens: Dict[str, Any]) -> bool:
+def _calculate_refresh_buffer(expires_in: Optional[float]) -> float:
+    default_buffer = float(TOKEN_REFRESH_BUFFER_SECONDS)
+    if expires_in is None:
+        return default_buffer
+    try:
+        expires_value = float(expires_in)
+    except (TypeError, ValueError):
+        return default_buffer
+    return min(default_buffer, max(MIN_REFRESH_BUFFER_SECONDS, expires_value * 0.1))
+
+
+def _get_expires_at_value(tokens: Dict[str, Any]) -> Optional[float]:
     expires_at = tokens.get("expires_at")
     if expires_at is None:
-        return False
+        return None
     try:
-        expires_at_value = float(expires_at)
+        return float(expires_at)
     except (TypeError, ValueError):
+        return None
+
+
+def _is_token_actually_expired(tokens: Dict[str, Any]) -> bool:
+    expires_at_value = _get_expires_at_value(tokens)
+    if expires_at_value is None:
+        return False
+    return time.time() >= expires_at_value
+
+
+def is_token_expired(tokens: Dict[str, Any]) -> bool:
+    expires_at_value = _get_expires_at_value(tokens)
+    if expires_at_value is None:
         return False
-    return time.time() >= expires_at_value - TOKEN_REFRESH_BUFFER_SECONDS
+    buffer_seconds = _calculate_refresh_buffer(tokens.get("expires_in"))
+    return time.time() >= expires_at_value - buffer_seconds
 
 
 def update_claude_code_model_tokens(access_token: str) -> bool:
@@ -216,11 +241,12 @@ def refresh_access_token(force: bool = False) -> Optional[str]:
             new_tokens = response.json()
             tokens["access_token"] = new_tokens.get("access_token")
             tokens["refresh_token"] = new_tokens.get("refresh_token", refresh_token)
-            if "expires_in" in new_tokens:
-                tokens["expires_in"] = new_tokens["expires_in"]
-                tokens["expires_at"] = _calculate_expires_at(
-                    new_tokens.get("expires_in")
-                )
+            expires_in_value = new_tokens.get("expires_in")
+            if expires_in_value is None:
+                expires_in_value = tokens.get("expires_in")
+            if expires_in_value is not None:
+                tokens["expires_in"] = expires_in_value
+                tokens["expires_at"] = _calculate_expires_at(expires_in_value)
             if save_tokens(tokens):
                 update_claude_code_model_tokens(tokens["access_token"])
                 return tokens["access_token"]
@@ -249,6 +275,11 @@ def get_valid_access_token() -> Optional[str]:
         refreshed = refresh_access_token()
         if refreshed:
             return refreshed
+        if not _is_token_actually_expired(tokens):
+            logger.warning(
+                "Claude Code token refresh failed; using existing access token until expiry"
+            )
+            return access_token
         logger.warning("Claude Code token refresh failed")
         return None
 

code_puppy/plugins/universal_constructor/__init__.py

@@ -0,0 +1,13 @@
+"""Universal Constructor - Dynamic tool creation and management plugin.
+
+This plugin enables users to create, manage, and deploy custom tools
+that extend Code Puppy's capabilities. Tools are stored in the user's
+config directory and can be organized into namespaces via subdirectories.
+"""
+
+from pathlib import Path
+
+# User tools directory - where user-created UC tools live
+USER_UC_DIR = Path.home() / ".code_puppy" / "plugins" / "universal_constructor"
+
+__all__ = ["USER_UC_DIR"]

code_puppy/plugins/universal_constructor/models.py

@@ -0,0 +1,138 @@
+"""Pydantic models for Universal Constructor tools and responses.
+
+This module defines the data structures used throughout the UC plugin
+for representing tool metadata, tool information, and operation responses.
+"""
+
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ToolMeta(BaseModel):
+    """Metadata for a UC tool.
+
+    This is the structure expected in the TOOL_META dictionary
+    at the top of each tool file.
+    """
+
+    name: str = Field(..., description="Human-readable tool name")
+    namespace: str = Field(
+        default="", description="Namespace for the tool (from subdirectory path)"
+    )
+    description: str = Field(..., description="What the tool does")
+    enabled: bool = Field(default=True, description="Whether the tool is active")
+    version: str = Field(default="1.0.0", description="Semantic version of the tool")
+    author: str = Field(default="", description="Tool author or creator")
+    created_at: Optional[str] = Field(
+        default=None, description="When the tool was created (ISO format string)"
+    )
+
+    model_config = {"extra": "allow"}  # Allow additional metadata fields
+
+
+class UCToolInfo(BaseModel):
+    """Full information about a UC tool.
+
+    Combines metadata with runtime information like function signature
+    and source file location.
+    """
+
+    meta: ToolMeta = Field(..., description="Tool metadata")
+    signature: str = Field(..., description="Function signature string")
+    source_path: str = Field(..., description="Path to the tool source file")
+    function_name: str = Field(default="", description="Name of the callable function")
+    docstring: Optional[str] = Field(default=None, description="Function docstring")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    @property
+    def full_name(self) -> str:
+        """Get the fully qualified tool name including namespace."""
+        if self.meta.namespace:
+            return f"{self.meta.namespace}.{self.meta.name}"
+        return self.meta.name
+
+
+# Response models for UC operations
+
+
+class UCListOutput(BaseModel):
+    """Response model for listing UC tools."""
+
+    tools: List[UCToolInfo] = Field(
+        default_factory=list, description="List of available tools"
+    )
+    total_count: int = Field(default=0, description="Total number of tools")
+    enabled_count: int = Field(default=0, description="Number of enabled tools")
+    error: Optional[str] = Field(default=None, description="Error message if any")
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCCallOutput(BaseModel):
+    """Response model for calling a UC tool."""
+
+    success: bool = Field(..., description="Whether the call succeeded")
+    tool_name: str = Field(..., description="Name of the tool that was called")
+    result: Any = Field(default=None, description="Return value from the tool")
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    execution_time: Optional[float] = Field(
+        default=None, description="Execution time in seconds"
+    )
+    source_preview: Optional[str] = Field(
+        default=None, description="Preview of the tool's source code that was executed"
+    )
+
+
+class UCCreateOutput(BaseModel):
+    """Response model for creating a UC tool."""
+
+    success: bool = Field(..., description="Whether creation succeeded")
+    tool_name: str = Field(default="", description="Name of the created tool")
+    source_path: Optional[str] = Field(
+        default=None, description="Path where tool was saved"
+    )
+    preview: Optional[str] = Field(
+        default=None, description="Preview of the first 10 lines of source code"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    validation_warnings: List[str] = Field(
+        default_factory=list, description="Non-fatal validation warnings"
+    )
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCUpdateOutput(BaseModel):
+    """Response model for updating a UC tool."""
+
+    success: bool = Field(..., description="Whether update succeeded")
+    tool_name: str = Field(default="", description="Name of the updated tool")
+    source_path: Optional[str] = Field(
+        default=None, description="Path to the updated tool"
+    )
+    preview: Optional[str] = Field(
+        default=None, description="Preview of the first 10 lines of updated source code"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    changes_applied: List[str] = Field(
+        default_factory=list, description="List of changes that were applied"
+    )
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+class UCInfoOutput(BaseModel):
+    """Response model for getting info about a specific UC tool."""
+
+    success: bool = Field(..., description="Whether lookup succeeded")
+    tool: Optional[UCToolInfo] = Field(
+        default=None, description="Tool information if found"
+    )
+    source_code: Optional[str] = Field(
+        default=None, description="Source code of the tool"
+    )
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+
+    model_config = {"arbitrary_types_allowed": True}

code_puppy/plugins/universal_constructor/register_callbacks.py

@@ -0,0 +1,47 @@
+"""Callback registration for the Universal Constructor plugin.
+
+This module registers callbacks to integrate UC with the rest of
+Code Puppy. It ensures the plugin is properly loaded and initialized.
+"""
+
+import logging
+
+from code_puppy.callbacks import register_callback
+
+from . import USER_UC_DIR
+from .registry import get_registry
+
+logger = logging.getLogger(__name__)
+
+
+def _on_startup() -> None:
+    """Initialize UC plugin on application startup."""
+    from code_puppy.config import get_universal_constructor_enabled
+
+    # Skip initialization if UC is disabled
+    if not get_universal_constructor_enabled():
+        logger.debug("Universal Constructor is disabled, skipping initialization")
+        return
+
+    logger.debug("Universal Constructor plugin initializing...")
+
+    # Ensure the user tools directory exists
+    USER_UC_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Do an initial scan of tools (lazy - will happen on first access)
+    registry = get_registry()
+    logger.debug(f"UC registry initialized, tools dir: {registry._tools_dir}")
+
+    # Log plugin info at startup
+    tools = registry.list_tools(include_disabled=True)
+    enabled = [t for t in tools if t.meta.enabled]
+    logger.debug(
+        f"UC plugin loaded: {len(enabled)}/{len(tools)} tools enabled "
+        f"from {USER_UC_DIR}"
+    )
+
+
+# Register startup callback
+register_callback("startup", _on_startup)
+
+logger.debug("Universal Constructor plugin callbacks registered")