devduck 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

devduck/__init__.py

@@ -183,6 +183,194 @@ Last Modified: {modified}"""
         return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
 
+def manage_tools_func(
+    action: str,
+    package: str = None,
+    tool_names: str = None,
+    tool_path: str = None,
+) -> Dict[str, Any]:
+    """
+    Manage the agent's tool set at runtime using ToolRegistry.
+
+    Args:
+        action: Action to perform - "list", "add", "remove", "reload"
+        package: Package name to load tools from (e.g., "strands_tools", "strands_fun_tools")
+        tool_names: Comma-separated tool names (e.g., "shell,editor,calculator")
+        tool_path: Path to a .py file to load as a tool
+
+    Returns:
+        Dict with status and content
+    """
+    try:
+        if not hasattr(devduck, "agent") or not devduck.agent:
+            return {"status": "error", "content": [{"text": "Agent not initialized"}]}
+
+        registry = devduck.agent.tool_registry
+
+        if action == "list":
+            # List tools from registry
+            tool_list = list(registry.registry.keys())
+            dynamic_tools = list(registry.dynamic_tools.keys())
+
+            text = f"Currently loaded {len(tool_list)} tools:\n"
+            text += "\n".join(f"  • {t}" for t in sorted(tool_list))
+            if dynamic_tools:
+                text += f"\n\nDynamic tools ({len(dynamic_tools)}):\n"
+                text += "\n".join(f"  • {t}" for t in sorted(dynamic_tools))
+
+            return {"status": "success", "content": [{"text": text}]}
+
+        elif action == "add":
+            if not package and not tool_path:
+                return {
+                    "status": "error",
+                    "content": [
+                        {
+                            "text": "Either 'package' or 'tool_path' required for add action"
+                        }
+                    ],
+                }
+
+            added_tools = []
+
+            # Add from package using process_tools
+            if package:
+                if not tool_names:
+                    return {
+                        "status": "error",
+                        "content": [
+                            {"text": "'tool_names' required when adding from package"}
+                        ],
+                    }
+
+                tools_to_add = [t.strip() for t in tool_names.split(",")]
+
+                # Build tool specs: package.tool_name format
+                tool_specs = [f"{package}.{tool_name}" for tool_name in tools_to_add]
+
+                try:
+                    added_tool_names = registry.process_tools(tool_specs)
+                    added_tools.extend(added_tool_names)
+                    logger.info(f"Added tools from {package}: {added_tool_names}")
+                except Exception as e:
+                    logger.error(f"Failed to add tools from {package}: {e}")
+                    return {
+                        "status": "error",
+                        "content": [{"text": f"Failed to add tools: {str(e)}"}],
+                    }
+
+            # Add from file path using process_tools
+            if tool_path:
+                try:
+                    added_tool_names = registry.process_tools([tool_path])
+                    added_tools.extend(added_tool_names)
+                    logger.info(f"Added tools from file: {added_tool_names}")
+                except Exception as e:
+                    logger.error(f"Failed to add tool from {tool_path}: {e}")
+                    return {
+                        "status": "error",
+                        "content": [{"text": f"Failed to add tool: {str(e)}"}],
+                    }
+
+            if added_tools:
+                return {
+                    "status": "success",
+                    "content": [
+                        {
+                            "text": f"✅ Added {len(added_tools)} tools: {', '.join(added_tools)}\n"
+                            + f"Total tools: {len(registry.registry)}"
+                        }
+                    ],
+                }
+            else:
+                return {"status": "error", "content": [{"text": "No tools were added"}]}
+
+        elif action == "remove":
+            if not tool_names:
+                return {
+                    "status": "error",
+                    "content": [{"text": "'tool_names' required for remove action"}],
+                }
+
+            tools_to_remove = [t.strip() for t in tool_names.split(",")]
+            removed_tools = []
+
+            # Remove from registry
+            for tool_name in tools_to_remove:
+                if tool_name in registry.registry:
+                    del registry.registry[tool_name]
+                    removed_tools.append(tool_name)
+                    logger.info(f"Removed tool: {tool_name}")
+
+                if tool_name in registry.dynamic_tools:
+                    del registry.dynamic_tools[tool_name]
+                    logger.info(f"Removed dynamic tool: {tool_name}")
+
+            if removed_tools:
+                return {
+                    "status": "success",
+                    "content": [
+                        {
+                            "text": f"✅ Removed {len(removed_tools)} tools: {', '.join(removed_tools)}\n"
+                            + f"Total tools: {len(registry.registry)}"
+                        }
+                    ],
+                }
+            else:
+                return {
+                    "status": "success",
+                    "content": [{"text": "No tools were removed (not found)"}],
+                }
+
+        elif action == "reload":
+            if tool_names:
+                # Reload specific tools
+                tools_to_reload = [t.strip() for t in tool_names.split(",")]
+                reloaded_tools = []
+                failed_tools = []
+
+                for tool_name in tools_to_reload:
+                    try:
+                        registry.reload_tool(tool_name)
+                        reloaded_tools.append(tool_name)
+                        logger.info(f"Reloaded tool: {tool_name}")
+                    except Exception as e:
+                        failed_tools.append((tool_name, str(e)))
+                        logger.error(f"Failed to reload {tool_name}: {e}")
+
+                text = ""
+                if reloaded_tools:
+                    text += f"✅ Reloaded {len(reloaded_tools)} tools: {', '.join(reloaded_tools)}\n"
+                if failed_tools:
+                    text += f"❌ Failed to reload {len(failed_tools)} tools:\n"
+                    for tool_name, error in failed_tools:
+                        text += f"  • {tool_name}: {error}\n"
+
+                return {"status": "success", "content": [{"text": text}]}
+            else:
+                # Reload all tools - restart agent
+                logger.info("Reloading all tools via restart")
+                devduck.restart()
+                return {
+                    "status": "success",
+                    "content": [{"text": "✅ All tools reloaded - agent restarted"}],
+                }
+
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"Unknown action: {action}. Valid: list, add, remove, reload"
+                    }
+                ],
+            }
+
+    except Exception as e:
+        logger.error(f"Error in manage_tools: {e}")
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
+
+
 def get_shell_history_file():
     """Get the devduck-specific history file path."""
     devduck_history = Path.home() / ".devduck_history"
@@ -380,6 +568,7 @@ class DevDuck:
         self,
         auto_start_servers=True,
         servers=None,
+        load_mcp_servers=True,
     ):
         """Initialize the minimalist adaptive agent
 
@@ -392,6 +581,7 @@ class DevDuck:
                     "mcp": {"port": 8000},
                     "ipc": {"socket_path": "/tmp/devduck.sock"}
                 }
+            load_mcp_servers: Load MCP servers from MCP_SERVERS env var
         """
         logger.info("Initializing DevDuck agent...")
         try:
@@ -441,14 +631,13 @@ class DevDuck:
 
             from strands import Agent, tool
 
-            # 🧰 Load tools with flexible configuration
-            tools_config = os.getenv("DEVDUCK_TOOLS")
-            if tools_config:
-                logger.info(f"Loading tools from DEVDUCK_TOOLS: {tools_config}")
-                core_tools = self._load_tools_from_config(tools_config)
-            else:
-                logger.info("Loading default tool set")
-                core_tools = self._load_default_tools()
+            # Load tools with flexible configuration
+            # Default tool config - user can override with DEVDUCK_TOOLS env var
+            default_tools = "devduck.tools:system_prompt,store_in_kb,ipc,tcp,websocket,mcp_server,state_manager,tray,ambient,agentcore_config,agentcore_invoke,agentcore_logs,agentcore_agents,install_tools,create_subagent,use_github:strands_tools:shell,editor,file_read,file_write,image_reader,load_tool,retrieve,calculator,use_agent,environment,mcp_client,speak,slack:strands_fun_tools:listen,cursor,clipboard,screen_reader,bluetooth,yolo_vision"
+
+            tools_config = os.getenv("DEVDUCK_TOOLS", default_tools)
+            logger.info(f"Loading tools from config: {tools_config}")
+            core_tools = self._load_tools_from_config(tools_config)
 
             # Wrap view_logs_tool with @tool decorator
             @tool
@@ -460,23 +649,51 @@ class DevDuck:
                 """View and manage DevDuck logs."""
                 return view_logs_tool(action, lines, pattern)
 
+            # Wrap manage_tools_func with @tool decorator
+            @tool
+            def manage_tools(
+                action: str,
+                package: str = None,
+                tool_names: str = None,
+                tool_path: str = None,
+            ) -> Dict[str, Any]:
+                """Manage the agent's tool set at runtime - add, remove, list, reload tools on the fly."""
+                return manage_tools_func(action, package, tool_names, tool_path)
+
             # Add built-in tools to the toolset
-            core_tools.extend([view_logs])
+            core_tools.extend([view_logs, manage_tools])
 
             # Assign tools
             self.tools = core_tools
 
+            # 🔌 Load MCP servers if enabled
+            if load_mcp_servers:
+                mcp_clients = self._load_mcp_servers()
+                if mcp_clients:
+                    self.tools.extend(mcp_clients)
+                    logger.info(f"Loaded {len(mcp_clients)} MCP server(s)")
+
             logger.info(f"Initialized {len(self.tools)} tools")
 
             # 🎯 Smart model selection
             self.agent_model, self.model = self._select_model()
 
             # Create agent with self-healing
+            # load_tools_from_directory controlled by DEVDUCK_LOAD_TOOLS_FROM_DIR (default: false)
+            load_from_dir = (
+                os.getenv("DEVDUCK_LOAD_TOOLS_FROM_DIR", "false").lower() == "true"
+            )
+
             self.agent = Agent(
                 model=self.agent_model,
                 tools=self.tools,
                 system_prompt=self._build_system_prompt(),
-                load_tools_from_directory=True,
+                load_tools_from_directory=load_from_dir,
+                trace_attributes={
+                    "session.id": self.session_id,
+                    "user.id": self.env_info["hostname"],
+                    "tags": ["Strands-Agents", "DevDuck"],
+                },
             )
 
             # 🚀 AUTO-START SERVERS
@@ -500,31 +717,22 @@ class DevDuck:
 
         Format: package:tool1,tool2:package2:tool3
         Example: strands_tools:shell,editor:strands_fun_tools:clipboard
+
+        Note: Only loads what's specified in config - no automatic additions
         """
         tools = []
-
-        # Always load DevDuck core tools
-        tools.extend(self._load_devduck_tools())
-
-        # Parse and load configured tools
         current_package = None
 
         for segment in config.split(":"):
             segment = segment.strip()
 
-            # Check if this segment is a package or tool list
-            if "," not in segment and not any(
-                segment.startswith(pkg)
-                for pkg in [
-                    "strands_",
-                    "devduck",
-                ]  # TODO: we should accept any python library here.
-            ):
-                # Single tool from current package
-                if current_package:
-                    tool = self._load_single_tool(current_package, segment)
-                    if tool:
-                        tools.append(tool)
+            # Check if segment is a package name (contains '.' or '_' and no ',')
+            is_package = "," not in segment and ("." in segment or "_" in segment)
+
+            if is_package:
+                # This is a package name - set as current package
+                current_package = segment
+                logger.debug(f"Switched to package: {current_package}")
             elif "," in segment:
                 # Tool list from current package
                 if current_package:
@@ -533,11 +741,15 @@ class DevDuck:
                         tool = self._load_single_tool(current_package, tool_name)
                         if tool:
                             tools.append(tool)
+            elif current_package:
+                # Single tool from current package
+                tool = self._load_single_tool(current_package, segment)
+                if tool:
+                    tools.append(tool)
             else:
-                # Package name
-                current_package = segment
+                logger.warning(f"Skipping segment '{segment}' - no package set")
 
-        logger.info(f"Loaded tools from DEVDUCK_TOOLS configuration")
+        logger.info(f"Loaded {len(tools)} tools from configuration")
         return tools
 
     def _load_single_tool(self, package, tool_name):
@@ -551,134 +763,103 @@ class DevDuck:
             logger.warning(f"Failed to load {tool_name} from {package}: {e}")
             return None
 
-    def _load_default_tools(self):
-        """Load default comprehensive tool set"""
-        tools = []
+    def _load_mcp_servers(self):
+        """
+        Load MCP servers from MCP_SERVERS environment variable using direct loading.
 
-        # Always load DevDuck core tools
-        tools.extend(self._load_devduck_tools())
+        Uses the experimental managed integration - MCPClient instances are passed
+        directly to Agent constructor without explicit context management.
+
+        Format: JSON with "mcpServers" object
+        Example: MCP_SERVERS='{"mcpServers": {"strands": {"command": "uvx", "args": ["strands-agents-mcp-server"]}}}'
+
+        Returns:
+            List of MCPClient instances ready for direct use in Agent
+        """
+        import json
+
+        mcp_servers_json = os.getenv("MCP_SERVERS")
+        if not mcp_servers_json:
+            logger.debug("No MCP_SERVERS environment variable found")
+            return []
 
-        # Load strands-agents-tools (essential)
         try:
-            from strands_tools import (
-                shell,
-                editor,
-                file_read,
-                file_write,
-                calculator,
-                image_reader,
-                use_agent,
-                load_tool,
-                environment,
-                mcp_client,
-                retrieve,
-            )
+            config = json.loads(mcp_servers_json)
+            mcp_servers_config = config.get("mcpServers", {})
 
-            tools.extend(
-                [
-                    shell,
-                    editor,
-                    file_read,
-                    file_write,
-                    calculator,
-                    image_reader,
-                    use_agent,
-                    load_tool,
-                    environment,
-                    mcp_client,
-                    retrieve,
-                ]
-            )
-            logger.info("✅ strands-agents-tools loaded")
-        except ImportError:
-            logger.info("strands-agents-tools unavailable")
+            if not mcp_servers_config:
+                logger.warning("MCP_SERVERS JSON has no 'mcpServers' key")
+                return []
 
-        # Load strands-fun-tools (optional, skip in --mcp mode)
-        if "--mcp" not in sys.argv:
-            try:
-                from strands_fun_tools import (
-                    listen,
-                    cursor,
-                    clipboard,
-                    screen_reader,
-                    yolo_vision,
-                )
+            mcp_clients = []
 
-                tools.extend([listen, cursor, clipboard, screen_reader, yolo_vision])
-                logger.info("✅ strands-fun-tools loaded")
-            except ImportError:
-                logger.info("strands-fun-tools unavailable")
+            from strands.tools.mcp import MCPClient
+            from mcp import stdio_client, StdioServerParameters
+            from mcp.client.streamable_http import streamablehttp_client
+            from mcp.client.sse import sse_client
 
-        return tools
+            for server_name, server_config in mcp_servers_config.items():
+                try:
+                    logger.info(f"Loading MCP server: {server_name}")
+
+                    # Determine transport type and create appropriate callable
+                    if "command" in server_config:
+                        # stdio transport
+                        command = server_config["command"]
+                        args = server_config.get("args", [])
+                        env = server_config.get("env", None)
+
+                        transport_callable = (
+                            lambda cmd=command, a=args, e=env: stdio_client(
+                                StdioServerParameters(command=cmd, args=a, env=e)
+                            )
+                        )
 
-    def _load_devduck_tools(self):
-        """Load DevDuck's core tools (always available)"""
-        tools = []
-        try:
-            from .tools import (
-                tcp,
-                websocket,
-                ipc,
-                mcp_server,
-                install_tools,
-                use_github,
-                create_subagent,
-                store_in_kb,
-                system_prompt,
-                state_manager,
-                tray,
-                ambient,
-            )
+                    elif "url" in server_config:
+                        # Determine if SSE or streamable HTTP based on URL path
+                        url = server_config["url"]
+                        headers = server_config.get("headers", None)
 
-            tools.extend(
-                [
-                    tcp,
-                    websocket,
-                    ipc,
-                    mcp_server,
-                    install_tools,
-                    use_github,
-                    create_subagent,
-                    store_in_kb,
-                    system_prompt,
-                    state_manager,
-                    tray,
-                    ambient,
-                ]
-            )
-            logger.info("✅ DevDuck core tools loaded")
-        except ImportError as e:
-            logger.warning(f"DevDuck tools unavailable: {e}")
+                        if "/sse" in url:
+                            # SSE transport
+                            transport_callable = lambda u=url: sse_client(u)
+                        else:
+                            # Streamable HTTP transport (default for HTTP)
+                            transport_callable = (
+                                lambda u=url, h=headers: streamablehttp_client(
+                                    url=u, headers=h
+                                )
+                            )
+                    else:
+                        logger.warning(
+                            f"MCP server {server_name} has no 'command' or 'url' - skipping"
+                        )
+                        continue
 
-        # Load AgentCore tools if AWS credentials available (conditional)
-        if os.getenv("DEVDUCK_DISABLE_AGENTCORE_TOOLS", "false").lower() != "true":
-            try:
-                import boto3
+                    # Create MCPClient with direct loading (experimental managed integration)
+                    # No need for context managers - Agent handles lifecycle
+                    prefix = server_config.get("prefix", server_name)
+                    mcp_client = MCPClient(
+                        transport_callable=transport_callable, prefix=prefix
+                    )
 
-                boto3.client("sts").get_caller_identity()
+                    mcp_clients.append(mcp_client)
+                    logger.info(
+                        f"✓ MCP server '{server_name}' loaded (prefix: {prefix})"
+                    )
 
-                from .tools.agentcore_config import agentcore_config
-                from .tools.agentcore_invoke import agentcore_invoke
-                from .tools.agentcore_logs import agentcore_logs
-                from .tools.agentcore_agents import agentcore_agents
-
-                tools.extend(
-                    [
-                        agentcore_config,
-                        agentcore_invoke,
-                        agentcore_logs,
-                        agentcore_agents,
-                    ]
-                )
-                logger.info("✅ AgentCore tools loaded")
-            except Exception as e:
-                logger.debug(f"AgentCore tools unavailable: {e}")
-        else:
-            logger.info(
-                "⏭️  AgentCore tools disabled (DEVDUCK_DISABLE_AGENTCORE_TOOLS=true)"
-            )
+                except Exception as e:
+                    logger.error(f"Failed to load MCP server '{server_name}': {e}")
+                    continue
 
-        return tools
+            return mcp_clients
+
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in MCP_SERVERS: {e}")
+            return []
+        except Exception as e:
+            logger.error(f"Error loading MCP servers: {e}")
+            return []
 
     def _select_model(self):
         """
@@ -768,6 +949,7 @@ class DevDuck:
         current_time = datetime.now().strftime("%I:%M %p")
 
         session_id = f"devduck-{datetime.now().strftime('%Y-%m-%d')}"
+        self.session_id = session_id
 
         # Get own file path for self-modification awareness
         own_file_path = Path(__file__).resolve()
@@ -834,12 +1016,19 @@ Set DEVDUCK_TOOLS for custom tools:
 - Example: strands_tools:shell,editor:strands_fun_tools:clipboard
 - Tools are filtered - only specified tools are loaded
 
-## MCP Server:
+## MCP Integration:
 - **Expose as MCP Server** - Use mcp_server() to expose devduck via MCP protocol
   - Example: mcp_server(action="start", port=8000)
   - Connect from Claude Desktop, other agents, or custom clients
   - Full bidirectional communication
 
+- **Load MCP Servers** - Set MCP_SERVERS env var to auto-load external MCP servers
+  - Format: JSON with "mcpServers" object
+  - Stdio servers: command, args, env keys
+  - HTTP servers: url, headers keys
+  - Example: MCP_SERVERS='{{"mcpServers": {{"strands": {{"command": "uvx", "args": ["strands-agents-mcp-server"]}}}}}}'
+  - Tools from MCP servers automatically available in agent context
+
 ## Knowledge Base Integration:
 - **Automatic RAG** - Set DEVDUCK_KNOWLEDGE_BASE_ID to enable automatic retrieval/storage
   - Before each query: Retrieves relevant context from knowledge base
@@ -1000,7 +1189,9 @@ When you learn something valuable during conversations:
                             logger.warning(f"No available ports found for TCP server")
                             continue
 
-                    result = self.agent.tool.tcp(action="start_server", port=port)
+                    result = self.agent.tool.tcp(
+                        action="start_server", port=port, record_direct_tool_call=False
+                    )
 
                     if result.get("status") == "success":
                         logger.info(f"✓ TCP server started on port {port}")
@@ -1022,7 +1213,9 @@ When you learn something valuable during conversations:
                             )
                             continue
 
-                    result = self.agent.tool.websocket(action="start_server", port=port)
+                    result = self.agent.tool.websocket(
+                        action="start_server", port=port, record_direct_tool_call=False
+                    )
 
                     if result.get("status") == "success":
                         logger.info(f"✓ WebSocket server started on port {port}")
@@ -1048,6 +1241,7 @@ When you learn something valuable during conversations:
                         port=port,
                         expose_agent=True,
                         agent=self.agent,
+                        record_direct_tool_call=False,
                     )
 
                     if result.get("status") == "success":
@@ -1075,7 +1269,9 @@ When you learn something valuable during conversations:
                         socket_path = available_socket
 
                     result = self.agent.tool.ipc(
-                        action="start_server", socket_path=socket_path
+                        action="start_server",
+                        socket_path=socket_path,
+                        record_direct_tool_call=False,
                     )
 
                     if result.get("status") == "success":
@@ -1094,6 +1290,7 @@ When you learn something valuable during conversations:
 
         try:
             logger.info(f"Agent call started: {query[:100]}...")
+
             # Mark agent as executing to prevent hot-reload interruption
             self._agent_executing = True
 
@@ -1133,7 +1330,7 @@ When you learn something valuable during conversations:
             # Check for pending hot-reload
             if self._reload_pending:
                 logger.info("Triggering pending hot-reload after agent completion")
-                print("🦆 Agent finished - triggering pending hot-reload...")
+                print("\n🦆 Agent finished - triggering pending hot-reload...")
                 self._hot_reload()
 
             return result
@@ -1148,7 +1345,7 @@ When you learn something valuable during conversations:
 
     def restart(self):
         """Restart the agent"""
-        print("🦆 Restarting...")
+        print("\n🦆 Restarting...")
         self.__init__()
 
     def _start_file_watcher(self):
@@ -1193,7 +1390,7 @@ When you learn something valuable during conversations:
                         and current_mtime > self._last_modified
                         and current_time - last_reload_time > debounce_seconds
                     ):
-                        print(f"🦆 Detected changes in {self._watch_file.name}!")
+                        print(f"\n🦆 Detected changes in {self._watch_file.name}!")
                         last_reload_time = current_time
 
                         # Check if agent is currently executing
@@ -1202,7 +1399,7 @@ When you learn something valuable during conversations:
                                 "Code change detected but agent is executing - reload pending"
                             )
                             print(
-                                "🦆 Agent is currently executing - reload will trigger after completion"
+                                "\n🦆 Agent is currently executing - reload will trigger after completion"
                             )
                             self._reload_pending = True
                             # Don't update _last_modified yet - keep detecting the change
@@ -1235,7 +1432,7 @@ When you learn something valuable during conversations:
     def _hot_reload(self):
         """Hot-reload by restarting the entire Python process with fresh code"""
         logger.info("Hot-reload initiated")
-        print("🦆 Hot-reloading via process restart...")
+        print("\n🦆 Hot-reloading via process restart...")
 
         try:
             # Set reload flag to prevent recursive reloads during shutdown
@@ -1252,7 +1449,7 @@ When you learn something valuable during conversations:
             if hasattr(self, "_watcher_running"):
                 self._watcher_running = False
 
-            print("🦆 Restarting process with fresh code...")
+            print("\n🦆 Restarting process with fresh code...")
 
             # Restart the entire Python process
             # This ensures all code is freshly loaded
@@ -1260,8 +1457,8 @@ When you learn something valuable during conversations:
 
         except Exception as e:
             logger.error(f"Hot-reload failed: {e}")
-            print(f"🦆 Hot-reload failed: {e}")
-            print("🦆 Falling back to manual restart")
+            print(f"\n🦆 Hot-reload failed: {e}")
+            print("\n🦆 Falling back to manual restart")
             self._is_reloading = False
 
     def status(self):
@@ -1552,6 +1749,7 @@ Claude Desktop Config:
                     transport="stdio",
                     expose_agent=True,
                     agent=devduck.agent,
+                    record_direct_tool_call=False,
                 )
             except Exception as e:
                 logger.error(f"Failed to start MCP stdio server: {e}")

devduck/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.6.0'
-__version_tuple__ = version_tuple = (0, 6, 0)
+__version__ = version = '0.7.0'
+__version_tuple__ = version_tuple = (0, 7, 0)
 
 __commit_id__ = commit_id = None

devduck/tools/agentcore_invoke.py

@@ -407,6 +407,7 @@ def agentcore_invoke(
         response_text = (
             "\n".join(str(e) for e in events) if events else "No response content"
         )
+        print("\n")
 
         return {
             "status": "success",

devduck/tools/install_tools.py

@@ -29,7 +29,7 @@ def install_tools(
     and loading their tools into the agent's registry at runtime.
 
     Args:
-        action: Action to perform - "install", "load", "install_and_load", "list_loaded"
+        action: Action to perform - "install", "load", "install_and_load", "list_loaded", "list_available"
         package: Python package to install (e.g., "strands-agents-tools", "strands-fun-tools")
         module: Module to import tools from (e.g., "strands_tools", "strands_fun_tools")
         tool_names: Optional list of specific tools to load. If None, loads all available tools
@@ -39,6 +39,13 @@ def install_tools(
         Result dictionary with status and content
 
     Examples:
+        # List available tools in a package (without loading)
+        install_tools(
+            action="list_available",
+            package="strands-fun-tools",
+            module="strands_fun_tools"
+        )
+
         # Install and load all tools from strands-agents-tools
         install_tools(
             action="install_and_load",
@@ -79,13 +86,15 @@ def install_tools(
             return _load_tools_from_module(module, tool_names, agent)
         elif action == "list_loaded":
             return _list_loaded_tools(agent)
+        elif action == "list_available":
+            return _list_available_tools(package, module)
         else:
             return {
                 "status": "error",
                 "content": [
                     {
                         "text": f"❌ Unknown action: {action}\n\n"
-                        f"Valid actions: install, load, install_and_load, list_loaded"
+                        f"Valid actions: install, load, install_and_load, list_loaded, list_available"
                     }
                 ],
             }
@@ -306,3 +315,95 @@ def _list_loaded_tools(agent: Any) -> Dict[str, Any]:
             "status": "error",
             "content": [{"text": f"❌ Failed to list tools: {str(e)}"}],
         }
+
+
+def _list_available_tools(package: Optional[str], module: str) -> Dict[str, Any]:
+    """List available tools in a package without loading them."""
+    if not module:
+        return {
+            "status": "error",
+            "content": [
+                {"text": "❌ module parameter is required for list_available action"}
+            ],
+        }
+
+    try:
+        # Try to import the module
+        try:
+            imported_module = importlib.import_module(module)
+            logger.info(f"Module {module} already installed")
+        except ImportError:
+            # Module not installed - try to install package first
+            if not package:
+                return {
+                    "status": "error",
+                    "content": [
+                        {
+                            "text": f"❌ Module {module} not found and no package specified to install.\n\n"
+                            f"Please provide the 'package' parameter to install first."
+                        }
+                    ],
+                }
+
+            logger.info(f"Module {module} not found, installing package {package}")
+            install_result = _install_package(package)
+            if install_result["status"] == "error":
+                return install_result
+
+            # Try importing again after installation
+            try:
+                imported_module = importlib.import_module(module)
+            except ImportError as e:
+                return {
+                    "status": "error",
+                    "content": [
+                        {
+                            "text": f"❌ Failed to import {module} even after installing {package}: {str(e)}"
+                        }
+                    ],
+                }
+
+        # Discover tools in the module
+        available_tools = {}
+        for attr_name in dir(imported_module):
+            attr = getattr(imported_module, attr_name)
+            # Check if it's a tool (has tool_name and tool_spec attributes)
+            if hasattr(attr, "tool_name") and hasattr(attr, "tool_spec"):
+                tool_spec = attr.tool_spec
+                description = tool_spec.get("description", "No description available")
+                available_tools[attr.tool_name] = description
+
+        if not available_tools:
+            return {
+                "status": "success",
+                "content": [{"text": f"⚠️  No tools found in module: {module}"}],
+            }
+
+        # Build result message
+        result_lines = [
+            f"📦 **Available Tools in {module} ({len(available_tools)})**\n"
+        ]
+
+        for tool_name, description in sorted(available_tools.items()):
+            # Truncate long descriptions
+            if len(description) > 100:
+                description = description[:97] + "..."
+
+            result_lines.append(f"**{tool_name}**")
+            result_lines.append(f"  {description}\n")
+
+        result_lines.append(f"\n💡 To load these tools, use:")
+        result_lines.append(f"   install_tools(action='load', module='{module}')")
+        result_lines.append(f"   # Or load specific tools:")
+        result_lines.append(
+            f"   install_tools(action='load', module='{module}', tool_names=['tool1', 'tool2'])"
+        )
+
+        return {"status": "success", "content": [{"text": "\n".join(result_lines)}]}
+
+    except Exception as e:
+        logger.exception(f"Error listing available tools from {module}")
+        return {
+            "status": "error",
+            "content": [{"text": f"❌ Failed to list available tools: {str(e)}"}],
+        }

{devduck-0.6.0.dist-info → devduck-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devduck
-Version: 0.6.0
+Version: 0.7.0
 Summary: 🦆 Extreme minimalist self-adapting AI agent - one file, self-healing, runtime dependencies
 Author-email: Cagatay Cali <cagataycali@icloud.com>
 License: Apache-2.0
@@ -53,6 +53,8 @@ Dynamic: license-file
 
 One Python file that adapts to your environment, fixes itself, and expands capabilities at runtime.
 
+Learn more: https://duck.nyc
+
 ## 🎬 See It In Action
 
 | Feature | What You'll See | Video |
@@ -176,7 +178,7 @@ devduck("refactor my code to use async/await")
 
 | Provider | Setup | When to Use |
 |----------|-------|-------------|
-| **Bedrock** (auto-detected) | [Get API key](https://console.aws.amazon.com/bedrock) → `export AWS_BEARER_TOKEN_BEDROCK=...` | Production (auto-selected if credentials found) |
+| **Bedrock** (auto-detected) | [Get API key](https://console.aws.amazon.com/bedrock) → `export AWS_BEARER_TOKEN_BEDROCK=...` | Auto-selected if credentials found |
 | **MLX** (macOS auto-detected) | Auto-detected on Apple Silicon | Local, optimized for M-series Macs |
 | **Ollama** (fallback) | `ollama pull qwen3:1.7b` | Local, free, private (used if Bedrock/MLX unavailable) |
 | **Anthropic** | `export ANTHROPIC_API_KEY=...` | Claude API direct access |
@@ -304,22 +306,75 @@ No restart. No configuration. Just works.
 |----------|---------|---------|
 | `MODEL_PROVIDER` | Auto-detect | `bedrock`, `anthropic`, `github`, `mlx`, `ollama` |
 | `STRANDS_MODEL_ID` | Auto | Model name (e.g., `qwen3:1.7b`, `claude-sonnet-4`) |
-| `DEVDUCK_TOOLS` | All | `pkg:tool1,tool2:pkg2:tool3` |
+| `DEVDUCK_TOOLS` | 37 default tools | `package:tool1,tool2:package2:tool3` format |
+| `DEVDUCK_LOAD_TOOLS_FROM_DIR` | `false` | `true`/`false` - Auto-load tools from `./tools/` directory |
 | `DEVDUCK_KNOWLEDGE_BASE_ID` | - | Bedrock KB ID for auto-RAG |
 | `DEVDUCK_TCP_PORT` | `9999` | TCP server port |
 | `DEVDUCK_ENABLE_TCP` | `true` | Enable/disable TCP |
 
-**Minimal config (shell + editor only):**
+### Tool Configuration Format
+
+**Format:** `package:tool1,tool2:package2:tool3`
+
+**Directory Auto-Loading:**
+
+By default, DevDuck **does not** automatically load tools from the `./tools/` directory. This gives you explicit control over which tools are loaded. To enable automatic loading of tools from `./tools/`, set:
+
 ```bash
+export DEVDUCK_LOAD_TOOLS_FROM_DIR=true
+devduck
+```
+
+When enabled, any `.py` file in `./tools/` with a `@tool` decorator will be loaded automatically. When disabled (default), you control tool loading via `DEVDUCK_TOOLS` or runtime `manage_tools()` calls.
+
+**Examples:**
+```bash
+# Minimal (shell + editor only)
 export DEVDUCK_TOOLS="strands_tools:shell,editor"
+
+# Dev tools only
+export DEVDUCK_TOOLS="strands_tools:shell,editor,file_read,file_write,calculator"
+
+# Full DevDuck + Strands (no fun tools)
+export DEVDUCK_TOOLS="devduck.tools:tcp,websocket,mcp_server,use_github:strands_tools:shell,editor,file_read"
+
+# Custom package
+export DEVDUCK_TOOLS="my_tools:custom_tool,another_tool:strands_tools:shell"
+
 devduck
 ```
 
+**Runtime tool management:**
+```python
+# List loaded tools
+manage_tools(action="list")
+
+# Add tools at runtime
+manage_tools(action="add", package="strands_fun_tools", tool_names="cursor,clipboard")
+
+# Remove tools
+manage_tools(action="remove", tool_names="cursor,clipboard")
+
+# Reload specific tools
+manage_tools(action="reload", tool_names="shell,editor")
+
+# Reload all (restart agent)
+manage_tools(action="reload")
+```
+
+**Discover tools before loading:**
+```python
+# List available tools in a package
+install_tools(action="list_available", package="strands-fun-tools", module="strands_fun_tools")
+```
+
 ---
 
 
 ## MCP Integration
 
+### Expose DevDuck as MCP Server
+
 **Claude Desktop** (`~/Library/Application Support/Claude/claude_desktop_config.json`):
 ```json
 {
@@ -334,6 +389,83 @@ devduck
 
 Restart Claude → DevDuck tools appear automatically.
 
+### Load External MCP Servers
+
+DevDuck can act as an MCP client and load tools from external MCP servers automatically.
+
+**Setup:**
+```bash
+export MCP_SERVERS='{
+  "mcpServers": {
+    "strands": {
+      "command": "uvx",
+      "args": ["strands-agents-mcp-server"]
+    }
+  }
+}'
+devduck
+```
+
+**Supported Transport Types:**
+
+| Transport | Configuration | Example |
+|-----------|--------------|---------|
+| **stdio** | `command`, `args`, `env` | Executables via stdin/stdout |
+| **HTTP** | `url`, `headers` | Remote servers via HTTP |
+| **SSE** | `url` (with `/sse` path) | Server-Sent Events streaming |
+
+**Examples:**
+
+```bash
+# Stdio server
+export MCP_SERVERS='{
+  "mcpServers": {
+    "myserver": {
+      "command": "python",
+      "args": ["server.py"],
+      "env": {"API_KEY": "secret"}
+    }
+  }
+}'
+
+# HTTP server
+export MCP_SERVERS='{
+  "mcpServers": {
+    "remote": {
+      "url": "https://api.example.com/mcp",
+      "headers": {"Authorization": "Bearer token"}
+    }
+  }
+}'
+
+# SSE server
+export MCP_SERVERS='{
+  "mcpServers": {
+    "events": {
+      "url": "https://api.example.com/sse"
+    }
+  }
+}'
+
+# Multiple servers
+export MCP_SERVERS='{
+  "mcpServers": {
+    "strands": {
+      "command": "uvx",
+      "args": ["strands-agents-mcp-server"]
+    },
+    "remote": {
+      "url": "https://api.example.com/mcp"
+    }
+  }
+}'
+
+devduck
+# Tools from all MCP servers automatically available
+```
+
+**Tool Prefixing:** Each MCP server's tools are prefixed with the server name (e.g., `strands_tool_name`)
+
 ---
 
 ## Troubleshooting

{devduck-0.6.0.dist-info → devduck-0.7.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-devduck/__init__.py,sha256=mRu9U3EYnxYhFs2xi_a8fX6-peFLgoeM31zlFGbXb3k,57904
+devduck/__init__.py,sha256=okf01FoPFrPpiwuGdQcx9Y7kLndn22JuVkA117L6g-4,67753
 devduck/__main__.py,sha256=aeF2RR4k7lzSR2X1QKV9XQPCKhtsH0JYUv2etBBqmL0,145
-devduck/_version.py,sha256=MAYWefOLb6kbIRub18WSzK6ggSjz1LNLy9aDRlX9Ea4,704
+devduck/_version.py,sha256=uLbRjFSUZAgfl7V7O8zKV5Db36k7tz87ZIVq3l2SWs0,704
 devduck/agentcore_handler.py,sha256=0DKJTTjoH9P8a70G0f5dOIIwy6bjqaN46voAWaSOpDY,2221
 devduck/test_redduck.py,sha256=ILtKKMuoyVfmhnibmbojpbOsqbcKooZv4j9qtE2LWdw,1750
 devduck/tools/__init__.py,sha256=AmIy8MInaClaZ71fqzy4EQJnBWsLkrv4QW9IIN7UQyw,1367
@@ -8,11 +8,11 @@ devduck/tools/_ambient_input.py,sha256=3lBgLO81BvkxjgTrQc-EuxNLXmO1oPUt2Ysg1jR4F
 devduck/tools/_tray_app.py,sha256=E4rtJcegRsBs_FdQVGdA-0Ax7uxVb6AbuyqjwCArHj0,19405
 devduck/tools/agentcore_agents.py,sha256=fiDNhl7R2tVbp1mEOySJTfGXwap5q3COenYOjiJDE_g,6488
 devduck/tools/agentcore_config.py,sha256=sUD1SrLAqTHjgHctZtVRDz_BvLG_nRB3z6g3EcrcvTM,14780
-devduck/tools/agentcore_invoke.py,sha256=SMKqVAig_cZEBL-W5gfumUpPFIHC9CSRSY9BJbnx6wY,17449
+devduck/tools/agentcore_invoke.py,sha256=iHOeV8mh1QeJ_dj06MRHbJ1VnvY4WIQxqruxIDw0mz0,17469
 devduck/tools/agentcore_logs.py,sha256=A3YQIoRErJtvzeaMSPNqOLX1BH-vYTbYKs1NXoCnC5E,10222
 devduck/tools/ambient.py,sha256=HB1ZhfeOdOaMU0xe4e44VNUT_-DQ5SY7sl3r4r-4X44,4806
 devduck/tools/create_subagent.py,sha256=UzRz9BmU4PbTveZROEpZ311aH-u-i6x89gttu-CniAE,24687
-devduck/tools/install_tools.py,sha256=wm_67b9IfY-2wRuWgxuEKhaSIV5vNfbGmZL3G9dGi2A,10348
+devduck/tools/install_tools.py,sha256=3uzRg5lEHX-L6gxnFn3mIKjGYDJ3h_AdwGnEwKA9qR0,14284
 devduck/tools/ipc.py,sha256=e3KJeR2HmCKEtVLGNOtf6CeFi3pTDehwd7Fu4JJ19Ms,18607
 devduck/tools/mcp_server.py,sha256=Ybp0PcJKW2TOvghsRL-i8Guqc9WokPwOD2bhVgzoj6Q,21490
 devduck/tools/state_manager.py,sha256=hrleqdVoCboNd8R3wDRUXVKYCZdGoe1j925i948LTHc,10563
@@ -22,9 +22,9 @@ devduck/tools/tcp.py,sha256=w2m_Jf6vZ4NYu0AwgZd7C7eKs4No2EVHZ2WYIl_Bt0A,22017
 devduck/tools/tray.py,sha256=FgVhUtLdsdv5_ERK-RyAIpDE8Zb0IfoqhHQdwMxrHUQ,7547
 devduck/tools/use_github.py,sha256=nr3JSGk48mKUobpgW__2gu6lFyUj93a1XRs3I6vH8W4,13682
 devduck/tools/websocket.py,sha256=A8bqgdDZs8hcf2HctkJzQOzMvb5mXUC7YZ-xqkOyn94,16959
-devduck-0.6.0.dist-info/licenses/LICENSE,sha256=UANcoWwfVeuM9597WUkjEQbzqIUH0bJoE9Tpwgj_LvU,11345
-devduck-0.6.0.dist-info/METADATA,sha256=u3rog7cs0uapLjeO8Oi8bZkoOjeOSQkWKRj65vwggkw,14518
-devduck-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-devduck-0.6.0.dist-info/entry_points.txt,sha256=BAMQaIg_BLZQOTk12bT7hy1dE9oGPLt-_dTbI4cnBnQ,40
-devduck-0.6.0.dist-info/top_level.txt,sha256=ySXWlVronp8xHYfQ_Hdfr463e0EnbWuqyuxs94EU7yk,8
-devduck-0.6.0.dist-info/RECORD,,
+devduck-0.7.0.dist-info/licenses/LICENSE,sha256=UANcoWwfVeuM9597WUkjEQbzqIUH0bJoE9Tpwgj_LvU,11345
+devduck-0.7.0.dist-info/METADATA,sha256=I7la6VIQ76TqoZkaJ-GbY09Mt5duZ_rMGtW8D1lD-OM,17748
+devduck-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+devduck-0.7.0.dist-info/entry_points.txt,sha256=BAMQaIg_BLZQOTk12bT7hy1dE9oGPLt-_dTbI4cnBnQ,40
+devduck-0.7.0.dist-info/top_level.txt,sha256=ySXWlVronp8xHYfQ_Hdfr463e0EnbWuqyuxs94EU7yk,8
+devduck-0.7.0.dist-info/RECORD,,