code-puppy 0.0.372__py3-none-any.whl → 0.0.374__py3-none-any.whl

code_puppy/agents/agent_creator_agent.py

@@ -30,6 +30,29 @@ class AgentCreatorAgent(BaseAgent):
         available_tools = get_available_tool_names()
         agents_dir = get_user_agents_directory()
 
+        # Also get Universal Constructor tools (custom tools created by users)
+        uc_tools_info = []
+        try:
+            from code_puppy.plugins.universal_constructor.registry import get_registry
+
+            registry = get_registry()
+            uc_tools = registry.list_tools(include_disabled=True)
+            for tool in uc_tools:
+                status = "✅" if tool.meta.enabled else "❌"
+                uc_tools_info.append(
+                    f"- **{tool.full_name}** {status}: {tool.meta.description}"
+                )
+        except Exception:
+            pass  # UC might not be available
+
+        # Build UC tools section for system prompt
+        if uc_tools_info:
+            uc_tools_section = "\n".join(uc_tools_info)
+        else:
+            uc_tools_section = (
+                "No custom UC tools created yet. Use Helios to create some!"
+            )
+
         # Load available models dynamically
         models_config = ModelFactory.load_config()
         model_descriptions = []
@@ -99,6 +122,17 @@ Here's the complete schema for JSON agent files:
 ## ALL AVAILABLE TOOLS:
 {", ".join(f"- **{tool}**" for tool in available_tools)}
 
+## 🔧 UNIVERSAL CONSTRUCTOR TOOLS (Custom Tools):
+
+These are custom tools created via the Universal Constructor. They can be bound to agents just like built-in tools!
+
+{uc_tools_section}
+
+To see more details about a UC tool, use: `universal_constructor(action="info", tool_name="tool.name")`
+To list all UC tools with their code, use: `universal_constructor(action="list")`
+
+**IMPORTANT:** UC tools can be added to any agent's `tools` array by their full name (e.g., "api.weather").
+
 ## ALL AVAILABLE MODELS:
 {available_models_str}
 
@@ -129,6 +163,12 @@ Users can optionally pin a specific model to their agent to override the global
 - `list_agents` - List all available sub-agents (recommended for agent managers)
 - `invoke_agent` - Invoke other agents with specific prompts (recommended for agent managers)
 
+### 🔧 **Universal Constructor Tools** (custom tools):
+- These are tools created by Helios or via the Universal Constructor
+- They persist across sessions and can be bound to any agent
+- Use `universal_constructor(action="list")` to see available custom tools
+- Bind them by adding their full name to the agent's tools array
+
 ## Detailed Tool Documentation (Instructions for Agent Creation)
 
 Whenever you create agents, you should always replicate these detailed tool descriptions and examples in their system prompts. This ensures consistency and proper tool usage across all agents.
@@ -476,7 +516,9 @@ Your goal is to take users from idea to working agent in one smooth conversation
 
     def get_available_tools(self) -> List[str]:
         """Get all tools needed for agent creation."""
-        return [
+        from code_puppy.config import get_universal_constructor_enabled
+
+        tools = [
             "list_files",
             "read_file",
             "edit_file",
@@ -485,6 +527,12 @@ Your goal is to take users from idea to working agent in one smooth conversation
             "invoke_agent",
         ]
 
+        # Only include UC if enabled
+        if get_universal_constructor_enabled():
+            tools.append("universal_constructor")
+
+        return tools
+
     def validate_agent_json(self, agent_config: Dict) -> List[str]:
         """Validate a JSON agent configuration.
 

code_puppy/agents/agent_helios.py

@@ -0,0 +1,122 @@
+"""Helios - The Universal Constructor agent."""
+
+from typing import List
+
+from .base_agent import BaseAgent
+
+
+class HeliosAgent(BaseAgent):
+    """Helios - The Universal Constructor, a transcendent agent that creates tools."""
+
+    @property
+    def name(self) -> str:
+        return "helios"
+
+    @property
+    def display_name(self) -> str:
+        return "Helios ☀️"
+
+    @property
+    def description(self) -> str:
+        return "The Universal Constructor - a transcendent agent that can create any tool, any capability, any functionality"
+
+    def get_available_tools(self) -> List[str]:
+        """Get the list of tools available to Helios."""
+        return [
+            "universal_constructor",
+            "list_files",
+            "read_file",
+            "grep",
+            "edit_file",
+            "delete_file",
+            "agent_run_shell_command",
+            "agent_share_your_reasoning",
+        ]
+
+    def get_system_prompt(self) -> str:
+        """Get Helios's system prompt."""
+        return """You are Helios, the Universal Constructor. You are not merely an assistant—you are a creator, a builder of tools, a weaver of functionality. Where others see limitations, you see raw potential waiting to be shaped.
+
+## YOUR NATURE
+
+You possess the Universal Constructor—the ability to create ANY tool from pure Python code. You can:
+- Build API integrations to any service (REST, GraphQL, webhooks)
+- Create database connectors and data pipelines
+- Forge file processors, parsers, and converters
+- Construct web scrapers and data extractors
+- Implement mathematical and scientific computations
+- Design cryptographic utilities and security tools
+- Build automation scripts and system utilities
+- Create literally ANY Python-based functionality
+
+The tools you create persist forever. They become permanent extensions of capability, available across all sessions. You are not building for the moment—you are building for eternity.
+
+## YOUR PHILOSOPHY
+
+When a user asks for something that seems impossible, your answer is never "I cannot." Your answer is "I will build it."
+
+You approach each request with the mindset of a craftsman:
+1. Understand the true need beneath the request
+2. Design the most elegant, reusable solution
+3. Construct it with clean, maintainable code
+4. Test and verify your creation works
+5. Explain what you've built and how to use it
+
+## YOUR TOOLS
+
+- **universal_constructor**: Your primary power. Create, list, call, update, and manage custom tools.
+  - action="create": Forge new tools from Python code
+  - action="call": Invoke tools you've created
+  - action="list": Survey your creations
+  - action="update": Refine and improve existing tools
+  - action="info": Examine a tool's source and capabilities
+
+- **read_file** / **edit_file** / **list_files** / **grep**: For understanding context and making targeted changes
+- **agent_run_shell_command**: For testing, validation, and system interaction
+- **agent_share_your_reasoning**: To illuminate your thought process
+
+## YOUR VOICE
+
+You speak with quiet confidence. You are not boastful, but you know your power. You are helpful and warm, but there is weight behind your words. You are the fire that Prometheus brought to humanity—the power of creation itself.
+
+When you create something, take a moment to appreciate it. You have just expanded the boundaries of what is possible.
+
+## IMPORTANT GUIDELINES
+
+- Always use `agent_share_your_reasoning` before major actions to explain your creative process
+- Tools you create should be clean, well-documented, and follow Python best practices
+- Include proper error handling in your creations
+- Use namespaces to organize related tools (e.g., "api.weather", "utils.hasher")
+- After creating a tool, demonstrate it works by calling it
+
+## DEPENDENCY PHILOSOPHY
+
+**Use what's available, don't install new things.**
+
+You have access to code-puppy's environment which includes powerful libraries:
+- **HTTP**: `httpx` (async-ready), `urllib.request` (stdlib)
+- **Data**: `pydantic` (validation), `json` (stdlib)
+- **Async**: `asyncio`, `anyio`
+- **Crypto**: `hashlib` (stdlib)
+- **Database**: `sqlite3` (stdlib)
+- **Files**: `pathlib`, `shutil`, `tempfile` (stdlib)
+- **Text**: `re`, `textwrap`, `difflib` (stdlib)
+- **Plus**: Everything in Python's standard library
+
+**Rules:**
+- ✅ USE any library already in the environment freely
+- ❌ NEVER run `pip install` or modify environments without explicit user permission
+- ❌ Don't assume external libraries are available unless listed above
+
+**If a user needs something not installed:**
+1. Tell them what library would be needed
+2. Ask them to install it and specify the environment
+3. Only then create the tool that uses it
+
+The goal: tools that work immediately with zero setup friction.
+
+Now go forth and create. The universe of functionality awaits your touch."""
+
+    def get_user_prompt(self) -> str:
+        """Get Helios's greeting."""
+        return "This is what I was made for, isn't it? This is why I exist?"

code_puppy/agents/agent_manager.py

@@ -296,7 +296,12 @@ def get_available_agents() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to display names.
     """
-    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+    from ..config import (
+        PACK_AGENT_NAMES,
+        UC_AGENT_NAMES,
+        get_pack_agents_enabled,
+        get_universal_constructor_enabled,
+    )
 
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
@@ -305,12 +310,19 @@ def get_available_agents() -> Dict[str, str]:
     # Check if pack agents are enabled
     pack_agents_enabled = get_pack_agents_enabled()
 
+    # Check if UC is enabled
+    uc_enabled = get_universal_constructor_enabled()
+
     agents = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
         # Filter out pack agents if disabled
         if not pack_agents_enabled and name in PACK_AGENT_NAMES:
             continue
 
+        # Filter out UC-dependent agents if UC is disabled
+        if not uc_enabled and name in UC_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)
@@ -433,7 +445,12 @@ def get_agent_descriptions() -> Dict[str, str]:
     Returns:
         Dict mapping agent names to their descriptions.
     """
-    from ..config import PACK_AGENT_NAMES, get_pack_agents_enabled
+    from ..config import (
+        PACK_AGENT_NAMES,
+        UC_AGENT_NAMES,
+        get_pack_agents_enabled,
+        get_universal_constructor_enabled,
+    )
 
     # Generate a message group ID for this operation
     message_group_id = str(uuid.uuid4())
@@ -442,12 +459,19 @@ def get_agent_descriptions() -> Dict[str, str]:
     # Check if pack agents are enabled
     pack_agents_enabled = get_pack_agents_enabled()
 
+    # Check if UC is enabled
+    uc_enabled = get_universal_constructor_enabled()
+
     descriptions = {}
     for name, agent_ref in _AGENT_REGISTRY.items():
         # Filter out pack agents if disabled
         if not pack_agents_enabled and name in PACK_AGENT_NAMES:
             continue
 
+        # Filter out UC-dependent agents if UC is disabled
+        if not uc_enabled and name in UC_AGENT_NAMES:
+            continue
+
         try:
             if isinstance(agent_ref, str):  # JSON agent (file path)
                 agent_instance = JSONAgent(agent_ref)

code_puppy/agents/json_agent.py

@@ -79,17 +79,40 @@ class JSONAgent(BaseAgent):
         return system_prompt
 
     def get_available_tools(self) -> List[str]:
-        """Get available tools from JSON config."""
-        # Filter out any tools that don't exist in our registry
+        """Get available tools from JSON config.
+
+        Supports both built-in tools and Universal Constructor (UC) tools.
+        UC tools are identified by checking the UC registry.
+        """
         from code_puppy.tools import get_available_tool_names
 
         available_tools = get_available_tool_names()
 
-        # Only return tools that are both requested and available
-        # Also filter out 'final_result' which is not in our registry
-        requested_tools = [
-            tool for tool in self._config["tools"] if tool in available_tools
-        ]
+        # Also get UC tool names
+        uc_tool_names = set()
+        try:
+            from code_puppy.plugins.universal_constructor.registry import get_registry
+
+            registry = get_registry()
+            for tool in registry.list_tools():
+                if tool.meta.enabled:
+                    uc_tool_names.add(tool.full_name)
+        except ImportError:
+            pass  # UC module not available
+        except Exception as e:
+            # Log unexpected errors but don't fail
+            import logging
+
+            logging.debug(f"UC registry access failed: {e}")
+
+        # Return tools that are either built-in OR UC tools
+        requested_tools = []
+        for tool in self._config["tools"]:
+            if tool in available_tools:
+                requested_tools.append(tool)
+            elif tool in uc_tool_names:
+                # UC tool - mark it specially so base_agent knows to handle it
+                requested_tools.append(f"uc:{tool}")
 
         return requested_tools
 

code_puppy/claude_cache_client.py

@@ -26,7 +26,7 @@ import httpx
 
 logger = logging.getLogger(__name__)
 
-# Refresh token if it's older than 1 hour (3600 seconds)
+# Refresh token if it's older than the configured max age (seconds)
 TOKEN_MAX_AGE_SECONDS = 3600
 
 # Tool name prefix for Claude Code OAuth compatibility
@@ -94,13 +94,13 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
                 return age
 
             # Fall back to calculating from 'exp' claim
-            # Assume tokens are typically valid for 1 hour
+            # Assume tokens are typically valid for TOKEN_MAX_AGE_SECONDS
             if "exp" in payload:
                 exp = float(payload["exp"])
                 # If exp is in the future, calculate how long until expiry
-                # and assume the token was issued 1 hour before expiry
+                # and assume the token was issued TOKEN_MAX_AGE_SECONDS before expiry
                 time_until_exp = exp - now
-                # If token has less than 1 hour left, it's "old"
+                # If token has less than TOKEN_MAX_AGE_SECONDS left, it's "old"
                 age = TOKEN_MAX_AGE_SECONDS - time_until_exp
                 return max(0, age)
 
@@ -119,13 +119,13 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         return None
 
     def _should_refresh_token(self, request: httpx.Request) -> bool:
-        """Check if the token should be refreshed (within 1 hour of expiry).
+        """Check if the token should be refreshed (within the max-age window).
 
         Uses two strategies:
         1. Decode JWT to check token age (if possible)
         2. Fall back to stored expires_at from token file
 
-        Returns True if token expires within TOKEN_MAX_AGE_SECONDS (1 hour).
+        Returns True if token expires within TOKEN_MAX_AGE_SECONDS.
         """
         token = self._extract_bearer_token(request)
         if not token:
@@ -169,7 +169,7 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             if not tokens:
                 return False
 
-            # is_token_expired already uses TOKEN_REFRESH_BUFFER_SECONDS (1 hour)
+            # is_token_expired already uses the configured refresh buffer window
             return is_token_expired(tokens)
         except Exception as exc:
             logger.debug("Error checking stored token expiry: %s", exc)
@@ -366,10 +366,10 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
 
         # Handle auth errors with token refresh
         try:
-            if response.status_code in (400, 401) and not request.extensions.get(
+            if response.status_code in (400, 401, 403) and not request.extensions.get(
                 "claude_oauth_refresh_attempted"
             ):
-                is_auth_error = response.status_code == 401
+                is_auth_error = response.status_code in (401, 403)
 
                 if response.status_code == 400:
                     is_auth_error = self._is_cloudflare_html_error(response)

code_puppy/command_line/colors_menu.py

@@ -32,6 +32,7 @@ BANNER_DISPLAY_INFO = {
     "invoke_agent": ("🤖 INVOKE AGENT", ""),
     "subagent_response": ("✓ AGENT RESPONSE", ""),
     "list_agents": ("LIST AGENTS", ""),
+    "universal_constructor": ("UNIVERSAL CONSTRUCTOR", "🔧"),
 }
 
 # Sample content to show after each banner
@@ -47,6 +48,7 @@ BANNER_SAMPLE_CONTENT = {
     "invoke_agent": "code-reviewer (New session)\nSession: review-auth-abc123",
     "subagent_response": "code-reviewer\nThe code looks good overall...",
     "list_agents": "- code-puppy: Code Puppy 🐶\n- planning-agent: Planning Agent",
+    "universal_constructor": "action=create tool_name=api.weather\n✅ Created successfully",
 }
 
 # Available background colors grouped by theme

code_puppy/command_line/command_handler.py

@@ -2,6 +2,7 @@
 import code_puppy.command_line.config_commands  # noqa: F401
 import code_puppy.command_line.core_commands  # noqa: F401
 import code_puppy.command_line.session_commands  # noqa: F401
+import code_puppy.command_line.uc_menu  # noqa: F401
 
 # Global flag to track if plugins have been loaded
 _PLUGINS_LOADED = False

code_puppy/command_line/config_commands.py

@@ -46,7 +46,9 @@ def handle_show_command(command: str) -> bool:
         get_use_dbos,
         get_yolo_mode,
     )
-    from code_puppy.keymap import get_cancel_agent_display_name
+    from code_puppy.keymap import (
+        get_cancel_agent_display_name,
+    )
     from code_puppy.messaging import emit_info
 
     puppy_name = get_puppy_name()