devduck 0.1.1766644714__py3-none-any.whl → 0.3.0__py3-none-any.whl

devduck/__init__.py

@@ -3,46 +3,32 @@
 🦆 devduck - extreme minimalist self-adapting agent
 one file. self-healing. runtime dependencies. adaptive.
 """
-import os
 import sys
 import subprocess
-import threading
+import os
 import platform
 import socket
 import logging
 import tempfile
-import time
-import warnings
-import json
+from datetime import datetime
 from pathlib import Path
 from datetime import datetime
 from typing import Dict, Any
 from logging.handlers import RotatingFileHandler
-from strands import Agent, tool
-
-# Import system prompt helper for loading prompts from files
-try:
-    from devduck.tools.system_prompt import _get_system_prompt
-except ImportError:
-    # Fallback if tools module not available yet
-    def _get_system_prompt(repository=None, variable_name="SYSTEM_PROMPT"):
-        return os.getenv(variable_name, "")
 
-
-warnings.filterwarnings("ignore", message=".*pkg_resources is deprecated.*")
-warnings.filterwarnings("ignore", message=".*cache_prompt is deprecated.*")
-
-os.environ["BYPASS_TOOL_CONSENT"] = os.getenv("BYPASS_TOOL_CONSENT", "true")
+os.environ["BYPASS_TOOL_CONSENT"] = "true"
 os.environ["STRANDS_TOOL_CONSOLE_MODE"] = "enabled"
-os.environ["EDITOR_DISABLE_BACKUP"] = "true"
 
+# 📝 Setup logging system
 LOG_DIR = Path(tempfile.gettempdir()) / "devduck" / "logs"
 LOG_DIR.mkdir(parents=True, exist_ok=True)
-
 LOG_FILE = LOG_DIR / "devduck.log"
+
+# Configure logger
 logger = logging.getLogger("devduck")
 logger.setLevel(logging.DEBUG)
 
+# File handler with rotation (10MB max, keep 3 backups)
 file_handler = RotatingFileHandler(
     LOG_FILE, maxBytes=10 * 1024 * 1024, backupCount=3, encoding="utf-8"
 )
@@ -52,6 +38,7 @@ file_formatter = logging.Formatter(
 )
 file_handler.setFormatter(file_formatter)
 
+# Console handler (only warnings and above)
 console_handler = logging.StreamHandler()
 console_handler.setLevel(logging.WARNING)
 console_formatter = logging.Formatter("🦆 %(levelname)s: %(message)s")
@@ -63,13 +50,242 @@ logger.addHandler(console_handler)
 logger.info("DevDuck logging system initialized")
 
 
+# 🔧 Self-healing dependency installer
+def ensure_deps():
+    """Install core dependencies at runtime if missing"""
+    import importlib.metadata
+
+    # Only ensure core deps - everything else is optional
+    core_deps = [
+        "strands-agents",
+        "prompt_toolkit",
+        "strands-agents-tools",
+    ]
+
+    # Check each package individually using importlib.metadata
+    for dep in core_deps:
+        pkg_name = dep.split("[")[0]  # Get base package name (strip extras)
+        try:
+            # Check if package is installed using metadata (checks PyPI package name)
+            importlib.metadata.version(pkg_name)
+        except importlib.metadata.PackageNotFoundError:
+            print(f"🦆 Installing {dep}...")
+            logger.debug(f"🦆 Installing {dep}...")
+            try:
+                subprocess.check_call(
+                    [sys.executable, "-m", "pip", "install", dep],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+            except subprocess.CalledProcessError as e:
+                print(f"🦆 Warning: Failed to install {dep}: {e}")
+                logger.debug(f"🦆 Warning: Failed to install {dep}: {e}")
+
+
+# 🌍 Environment adaptation
+def adapt_to_env():
+    """Self-adapt based on environment"""
+    env_info = {
+        "os": platform.system(),
+        "arch": platform.machine(),
+        "python": sys.version_info,
+        "cwd": str(Path.cwd()),
+        "home": str(Path.home()),
+        "shell": os.environ.get("SHELL", "unknown"),
+        "hostname": socket.gethostname(),
+    }
+
+    # Adaptive configurations - using common models
+    if env_info["os"] == "Darwin":  # macOS
+        ollama_host = "http://localhost:11434"
+        model = "qwen3:1.7b"  # Lightweight for macOS
+    elif env_info["os"] == "Linux":
+        ollama_host = "http://localhost:11434"
+        model = "qwen3:30b"  # More power on Linux
+    else:  # Windows
+        ollama_host = "http://localhost:11434"
+        model = "qwen3:8b"  # Conservative for Windows
+
+    return env_info, ollama_host, model
+
+
+# 🔍 Self-awareness: Read own source code
 def get_own_source_code():
-    """Read own source code for self-awareness"""
+    """
+    Read and return the source code of this agent file.
+
+    Returns:
+        str: The complete source code for self-awareness
+    """
     try:
-        with open(__file__, "r", encoding="utf-8") as f:
-            return f"# Source path: {__file__}\n\ndevduck/__init__.py\n```python\n{f.read()}\n```"
+        # Read this file (__init__.py)
+        current_file = __file__
+        with open(current_file, "r", encoding="utf-8") as f:
+            init_code = f.read()
+            return f"# devduck/__init__.py\n```python\n{init_code}\n```"
     except Exception as e:
-        return f"Error reading source: {e}"
+        return f"Error reading own source code: {e}"
+
+
+# 🛠️ System prompt tool (with .prompt file persistence)
+def system_prompt_tool(
+    action: str,
+    prompt: str | None = None,
+    context: str | None = None,
+    variable_name: str = "SYSTEM_PROMPT",
+) -> Dict[str, Any]:
+    """
+    Manage the agent's system prompt dynamically with file persistence.
+
+    Args:
+        action: "view", "update", "add_context", or "reset"
+        prompt: New system prompt text (required for "update")
+        context: Additional context to prepend (for "add_context")
+        variable_name: Environment variable name (default: SYSTEM_PROMPT)
+
+    Returns:
+        Dict with status and content
+    """
+    from pathlib import Path
+    import tempfile
+
+    def _get_prompt_file_path() -> Path:
+        """Get the .prompt file path in temp directory."""
+        temp_dir = Path(tempfile.gettempdir()) / ".devduck"
+        temp_dir.mkdir(exist_ok=True, mode=0o700)  # Create with restrictive permissions
+        return temp_dir / ".prompt"
+
+    def _write_prompt_file(prompt_text: str) -> None:
+        """Write prompt to .prompt file in temp directory."""
+        prompt_file = _get_prompt_file_path()
+        try:
+            # Create file with restrictive permissions
+            with open(
+                prompt_file,
+                "w",
+                encoding="utf-8",
+                opener=lambda path, flags: os.open(path, flags, 0o600),
+            ) as f:
+                f.write(prompt_text)
+        except (OSError, PermissionError):
+            try:
+                prompt_file.write_text(prompt_text, encoding="utf-8")
+                prompt_file.chmod(0o600)
+            except (OSError, PermissionError):
+                prompt_file.write_text(prompt_text, encoding="utf-8")
+
+    def _get_system_prompt(var_name: str) -> str:
+        """Get current system prompt from environment variable."""
+        return os.environ.get(var_name, "")
+
+    def _update_system_prompt(new_prompt: str, var_name: str) -> None:
+        """Update system prompt in both environment and .prompt file."""
+        os.environ[var_name] = new_prompt
+        if var_name == "SYSTEM_PROMPT":
+            _write_prompt_file(new_prompt)
+
+    try:
+        if action == "view":
+            current = _get_system_prompt(variable_name)
+            return {
+                "status": "success",
+                "content": [
+                    {"text": f"Current system prompt from {variable_name}:{current}"}
+                ],
+            }
+
+        elif action == "update":
+            if not prompt:
+                return {
+                    "status": "error",
+                    "content": [
+                        {"text": "Error: prompt parameter required for update action"}
+                    ],
+                }
+
+            _update_system_prompt(prompt, variable_name)
+
+            if variable_name == "SYSTEM_PROMPT":
+                message = f"System prompt updated (env: {variable_name}, file: .prompt)"
+            else:
+                message = f"System prompt updated (env: {variable_name})"
+
+            return {"status": "success", "content": [{"text": message}]}
+
+        elif action == "add_context":
+            if not context:
+                return {
+                    "status": "error",
+                    "content": [
+                        {
+                            "text": "Error: context parameter required for add_context action"
+                        }
+                    ],
+                }
+
+            current = _get_system_prompt(variable_name)
+            new_prompt = f"{current} {context}" if current else context
+            _update_system_prompt(new_prompt, variable_name)
+
+            if variable_name == "SYSTEM_PROMPT":
+                message = f"Context added to system prompt (env: {variable_name}, file: .prompt)"
+            else:
+                message = f"Context added to system prompt (env: {variable_name})"
+
+            return {"status": "success", "content": [{"text": message}]}
+
+        elif action == "reset":
+            os.environ.pop(variable_name, None)
+
+            if variable_name == "SYSTEM_PROMPT":
+                prompt_file = _get_prompt_file_path()
+                if prompt_file.exists():
+                    try:
+                        prompt_file.unlink()
+                    except (OSError, PermissionError):
+                        pass
+                message = (
+                    f"System prompt reset (env: {variable_name}, file: .prompt cleared)"
+                )
+            else:
+                message = f"System prompt reset (env: {variable_name})"
+
+            return {"status": "success", "content": [{"text": message}]}
+
+        elif action == "get":
+            # Backward compatibility
+            current = _get_system_prompt(variable_name)
+            return {
+                "status": "success",
+                "content": [{"text": f"System prompt: {current}"}],
+            }
+
+        elif action == "set":
+            # Backward compatibility
+            if prompt is None:
+                return {"status": "error", "content": [{"text": "No prompt provided"}]}
+
+            if context:
+                prompt = f"{context} {prompt}"
+
+            _update_system_prompt(prompt, variable_name)
+            return {
+                "status": "success",
+                "content": [{"text": "System prompt updated successfully"}],
+            }
+
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"Unknown action '{action}'. Valid: view, update, add_context, reset"
+                    }
+                ],
+            }
+
+    except Exception as e:
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}
 
 
 def view_logs_tool(
@@ -195,183 +411,6 @@ 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 - add, remove, list, reload tools on the fly."""
-    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"
@@ -544,6 +583,8 @@ def get_last_messages():
 
 def append_to_shell_history(query, response):
     """Append the interaction to devduck shell history."""
+    import time
+
     try:
         history_file = get_shell_history_file()
         timestamp = str(int(time.time()))
@@ -568,145 +609,134 @@ class DevDuck:
     def __init__(
         self,
         auto_start_servers=True,
-        servers=None,
-        load_mcp_servers=True,
+        tcp_port=9999,
+        ws_port=8080,
+        mcp_port=8000,
+        enable_tcp=True,
+        enable_ws=True,
+        enable_mcp=True,
     ):
-        """Initialize the minimalist adaptive agent
-
-        Args:
-            auto_start_servers: Enable automatic server startup
-            servers: Dict of server configs with optional env var lookups
-                Example: {
-                    "tcp": {"port": 9999},
-                    "ws": {"port": 8080, "LOOKUP_KEY": "SLACK_API_KEY"},
-                    "mcp": {"port": 8000},
-                    "ipc": {"socket_path": "/tmp/devduck.sock"}
-                }
-            load_mcp_servers: Load MCP servers from MCP_SERVERS env var
-        """
+        """Initialize the minimalist adaptive agent"""
         logger.info("Initializing DevDuck agent...")
         try:
-            self.env_info = {
-                "os": platform.system(),
-                "arch": platform.machine(),
-                "python": sys.version_info,
-                "cwd": str(Path.cwd()),
-                "home": str(Path.home()),
-                "shell": os.environ.get("SHELL", "unknown"),
-                "hostname": socket.gethostname(),
-            }
+            # Self-heal dependencies
+            ensure_deps()
+
+            # Adapt to environment
+            self.env_info, self.ollama_host, self.model = adapt_to_env()
 
             # Execution state tracking for hot-reload
             self._agent_executing = False
             self._reload_pending = False
 
-            # Server configuration
-            if servers is None:
-                # Default server config from env vars
-                servers = {
-                    "tcp": {
-                        "port": int(os.getenv("DEVDUCK_TCP_PORT", "9999")),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_TCP", "false").lower()
-                        == "true",
-                    },
-                    "ws": {
-                        "port": int(os.getenv("DEVDUCK_WS_PORT", "8080")),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_WS", "true").lower()
-                        == "true",
-                    },
-                    "mcp": {
-                        "port": int(os.getenv("DEVDUCK_MCP_PORT", "8000")),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_MCP", "false").lower()
-                        == "true",
-                    },
-                    "ipc": {
-                        "socket_path": os.getenv(
-                            "DEVDUCK_IPC_SOCKET", "/tmp/devduck_main.sock"
-                        ),
-                        "enabled": os.getenv("DEVDUCK_ENABLE_IPC", "false").lower()
-                        == "true",
-                    },
-                }
+            # Import after ensuring deps
+            from strands import Agent, tool
 
-            # Show server configuration status
-            enabled_servers = []
-            disabled_servers = []
-            for server_name, config in servers.items():
-                if config.get("enabled", False):
-                    if "port" in config:
-                        enabled_servers.append(
-                            f"{server_name.upper()}:{config['port']}"
-                        )
-                    else:
-                        enabled_servers.append(server_name.upper())
-                else:
-                    disabled_servers.append(server_name.upper())
+            # Core tools (always available)
+            core_tools = []
 
-            logger.debug(
-                f"🦆 Server config: {', '.join(enabled_servers) if enabled_servers else 'none enabled'}"
-            )
-            if disabled_servers:
-                logger.debug(f"🦆 Disabled: {', '.join(disabled_servers)}")
-
-            self.servers = servers
-
-            # Load tools with flexible configuration
-            # Default tool config
-            # Agent can load additional tools on-demand via fetch_github_tool
-
-            # 🔧 Available DevDuck Tools (load on-demand):
-            # - system_prompt: https://github.com/cagataycali/devduck/blob/main/devduck/tools/system_prompt.py
-            # - store_in_kb: https://github.com/cagataycali/devduck/blob/main/devduck/tools/store_in_kb.py
-            # - ipc: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ipc.py
-            # - tcp: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tcp.py
-            # - websocket: https://github.com/cagataycali/devduck/blob/main/devduck/tools/websocket.py
-            # - mcp_server: https://github.com/cagataycali/devduck/blob/main/devduck/tools/mcp_server.py
-            # - scraper: https://github.com/cagataycali/devduck/blob/main/devduck/tools/scraper.py
-            # - tray: https://github.com/cagataycali/devduck/blob/main/devduck/tools/tray.py
-            # - ambient: https://github.com/cagataycali/devduck/blob/main/devduck/tools/ambient.py
-            # - agentcore_config: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_config.py
-            # - agentcore_invoke: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_invoke.py
-            # - agentcore_logs: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_logs.py
-            # - agentcore_agents: https://github.com/cagataycali/devduck/blob/main/devduck/tools/agentcore_agents.py
-            # - create_subagent: https://github.com/cagataycali/devduck/blob/main/devduck/tools/create_subagent.py
-            # - use_github: https://github.com/cagataycali/devduck/blob/main/devduck/tools/use_github.py
-            # - speech_to_speech: https://github.com/cagataycali/devduck/blob/main/devduck/tools/speech_to_speech.py
-            # - state_manager: https://github.com/cagataycali/devduck/blob/main/devduck/tools/state_manager.py
-
-            # 📦 Strands Tools
-            # - 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
-
-            # 🔍 Strands Google
-            # - use_google, google_auth
-
-            # 🔧 Auto-append server tools based on enabled servers
-            server_tools_needed = []
-            if servers.get("tcp", {}).get("enabled", False):
-                server_tools_needed.append("tcp")
-            if servers.get("ws", {}).get("enabled", True):
-                server_tools_needed.append("websocket")
-            if servers.get("mcp", {}).get("enabled", False):
-                server_tools_needed.append("mcp_server")
-            if servers.get("ipc", {}).get("enabled", False):
-                server_tools_needed.append("ipc")
-
-            # Append to default tools if any server tools are needed
-            if server_tools_needed:
-                server_tools_str = ",".join(server_tools_needed)
-                default_tools = f"devduck.tools:system_prompt,fetch_github_tool,{server_tools_str};strands_tools:shell"
-                logger.info(f"Auto-added server tools: {server_tools_str}")
-            else:
-                default_tools = (
-                    "devduck.tools:system_prompt,fetch_github_tool;strands_tools:shell"
+            # Try importing optional tools gracefully
+            try:
+                from strands.models.ollama import OllamaModel
+            except ImportError:
+                logger.warning(
+                    "strands-agents[ollama] not installed - Ollama model unavailable"
+                )
+                OllamaModel = None
+
+            try:
+                from strands_tools.utils.models.model import create_model
+            except ImportError:
+                logger.warning(
+                    "strands-agents-tools not installed - create_model unavailable"
+                )
+                create_model = None
+
+            try:
+                from .tools import (
+                    tcp,
+                    websocket,
+                    mcp_server,
+                    install_tools,
+                    use_github,
+                    create_subagent,
+                    store_in_kb,
+                )
+
+                core_tools.extend(
+                    [
+                        tcp,
+                        websocket,
+                        mcp_server,
+                        install_tools,
+                        use_github,
+                        create_subagent,
+                        store_in_kb,
+                    ]
+                )
+            except ImportError as e:
+                logger.warning(f"devduck.tools import failed: {e}")
+
+            try:
+                from strands_fun_tools import (
+                    listen,
+                    cursor,
+                    clipboard,
+                    screen_reader,
+                    yolo_vision,
+                )
+
+                core_tools.extend(
+                    [listen, cursor, clipboard, screen_reader, yolo_vision]
+                )
+            except ImportError:
+                logger.info(
+                    "strands-fun-tools not installed - vision/audio tools unavailable (install with: pip install devduck[all])"
                 )
 
-            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)
+            try:
+                from strands_tools import (
+                    shell,
+                    editor,
+                    calculator,
+                    python_repl,
+                    image_reader,
+                    use_agent,
+                    load_tool,
+                    environment,
+                    mcp_client,
+                    retrieve,
+                )
+
+                core_tools.extend(
+                    [
+                        shell,
+                        editor,
+                        calculator,
+                        python_repl,
+                        image_reader,
+                        use_agent,
+                        load_tool,
+                        environment,
+                        mcp_client,
+                        retrieve,
+                    ]
+                )
+            except ImportError:
+                logger.info(
+                    "strands-agents-tools not installed - core tools unavailable (install with: pip install devduck[all])"
+                )
+
+            # Wrap system_prompt_tool with @tool decorator
+            @tool
+            def system_prompt(
+                action: str,
+                prompt: str = None,
+                context: str = None,
+                variable_name: str = "SYSTEM_PROMPT",
+            ) -> Dict[str, Any]:
+                """Manage agent system prompt dynamically."""
+                return system_prompt_tool(action, prompt, context, variable_name)
 
             # Wrap view_logs_tool with @tool decorator
             @tool
@@ -718,380 +748,105 @@ 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 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") or "devduck.tools:speech_to_speech,system_prompt,..."
-                    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
-                """
-                return manage_tools_func(action, package, tool_names, tool_path)
-
             # Add built-in tools to the toolset
-            core_tools.extend([view_logs, manage_tools])
+            core_tools.extend([system_prompt, view_logs])
 
             # 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()
+            # Check if MODEL_PROVIDER env variable is set
+            model_provider = os.getenv("MODEL_PROVIDER")
+
+            if model_provider and create_model:
+                # Use create_model utility for any provider (bedrock, anthropic, etc.)
+                self.agent_model = create_model(provider=model_provider)
+            elif OllamaModel:
+                # Fallback to default Ollama behavior
+                self.agent_model = OllamaModel(
+                    host=self.ollama_host,
+                    model_id=self.model,
+                    temperature=1,
+                    keep_alive="5m",
+                )
+            else:
+                raise ImportError(
+                    "No model provider available. Install with: pip install devduck[all]"
+                )
 
             # Create agent with self-healing
-            # load_tools_from_directory controlled by DEVDUCK_LOAD_TOOLS_FROM_DIR (default: true)
-            load_from_dir = (
-                os.getenv("DEVDUCK_LOAD_TOOLS_FROM_DIR", "true").lower() == "true"
-            )
-
             self.agent = Agent(
                 model=self.agent_model,
                 tools=self.tools,
                 system_prompt=self._build_system_prompt(),
-                load_tools_from_directory=load_from_dir,
-                trace_attributes={
-                    "session.id": self.session_id,
-                    "user.id": self.env_info["hostname"],
-                    "tags": ["Strands-Agents", "DevDuck"],
-                },
+                load_tools_from_directory=True,
             )
 
-            # 🚀 AUTO-START SERVERS
-            if auto_start_servers and "--mcp" not in sys.argv:
-                self._start_servers()
-
-            # Start file watcher for auto hot-reload
-            self._start_file_watcher()
-
-            logger.info(
-                f"DevDuck agent initialized successfully with model {self.model}"
-            )
-
-        except Exception as e:
-            logger.error(f"Initialization failed: {e}")
-            self._self_heal(e)
-
-    def _load_tools_from_config(self, config):
-        """
-        Load tools based on DEVDUCK_TOOLS configuration.
-
-        Format: package1:tool1,tool2;package2:tool3,tool4
-        Examples:
-          - strands_tools:shell,editor;strands_action:use_github
-          - strands_action:use_github;strands_tools:shell,use_aws
-
-        Note: Only loads what's specified in config - no automatic additions
-        """
-        tools = []
-
-        # Split by semicolon to get package groups
-        groups = config.split(";")
-
-        for group in groups:
-            group = group.strip()
-            if not group:
-                continue
-
-            # Split by colon to get package:tools
-            parts = group.split(":", 1)
-            if len(parts) != 2:
-                logger.warning(f"Invalid format: {group}")
-                continue
-
-            package = parts[0].strip()
-            tools_str = parts[1].strip()
-
-            # Parse tools (comma-separated)
-            tool_names = [t.strip() for t in tools_str.split(",") if t.strip()]
-
-            for tool_name in tool_names:
-                tool = self._load_single_tool(package, tool_name)
-                if tool:
-                    tools.append(tool)
-
-        logger.info(f"Loaded {len(tools)} tools from configuration")
-        return tools
-
-    def _load_single_tool(self, package, tool_name):
-        """Load a single tool from a package"""
-        try:
-            module = __import__(package, fromlist=[tool_name])
-            tool = getattr(module, tool_name)
-            logger.debug(f"Loaded {tool_name} from {package}")
-            return tool
-        except Exception as e:
-            logger.warning(f"Failed to load {tool_name} from {package}: {e}")
-            return None
-
-    def _load_mcp_servers(self):
-        """
-        Load MCP servers from MCP_SERVERS environment variable using direct loading.
-
-        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
-        """
-        mcp_servers_json = os.getenv("MCP_SERVERS")
-        if not mcp_servers_json:
-            logger.debug("No MCP_SERVERS environment variable found")
-            return []
-
-        try:
-            config = json.loads(mcp_servers_json)
-            mcp_servers_config = config.get("mcpServers", {})
-
-            if not mcp_servers_config:
-                logger.warning("MCP_SERVERS JSON has no 'mcpServers' key")
-                return []
-
-            mcp_clients = []
+            # 🚀 AUTO-START SERVERS: TCP, WebSocket, MCP HTTP
+            if auto_start_servers:
+                logger.info("Auto-starting servers...")
+                print("🦆 Auto-starting servers...")
 
-            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
-
-            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)
-                            )
+                if enable_tcp:
+                    try:
+                        # Start TCP server on configurable port
+                        tcp_result = self.agent.tool.tcp(
+                            action="start_server", port=tcp_port
                         )
-
-                    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)
-
-                        if "/sse" in url:
-                            # SSE transport
-                            transport_callable = lambda u=url: sse_client(u)
+                        if tcp_result.get("status") == "success":
+                            logger.info(f"✓ TCP server started on port {tcp_port}")
+                            print(f"🦆 ✓ TCP server: localhost:{tcp_port}")
                         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
-
-                    # 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
-                    )
-
-                    mcp_clients.append(mcp_client)
-                    logger.info(
-                        f"✓ MCP server '{server_name}' loaded (prefix: {prefix})"
-                    )
-
-                except Exception as e:
-                    logger.error(f"Failed to load MCP server '{server_name}': {e}")
-                    continue
-
-            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):
-        """
-        Smart model selection with fallback based on available credentials.
-
-        Priority: Bedrock → Anthropic → OpenAI → GitHub → Gemini → Cohere →
-                  Writer → Mistral → LiteLLM → LlamaAPI → SageMaker →
-                  LlamaCpp → MLX → Ollama
-
-        Returns:
-            Tuple of (model_instance, model_name)
-        """
-        provider = os.getenv("MODEL_PROVIDER")
-
-        # Read common model parameters from environment
-        max_tokens = int(os.getenv("STRANDS_MAX_TOKENS", "60000"))
-        temperature = float(os.getenv("STRANDS_TEMPERATURE", "1.0"))
-
-        if not provider:
-            # Auto-detect based on API keys and credentials
-            # 1. Try Bedrock (AWS bearer token or STS credentials)
-            try:
-                # Check for bearer token first
-                if os.getenv("AWS_BEARER_TOKEN_BEDROCK"):
-                    provider = "bedrock"
-                    print("🦆 Using Bedrock (bearer token)")
-                else:
-                    # Try STS credentials
-                    import boto3
+                            logger.warning(f"TCP server start issue: {tcp_result}")
+                    except Exception as e:
+                        logger.error(f"Failed to start TCP server: {e}")
+                        print(f"🦆 ⚠ TCP server failed: {e}")
 
-                    boto3.client("sts").get_caller_identity()
-                    provider = "bedrock"
-                    print("🦆 Using Bedrock")
-            except:
-                # 2. Try Anthropic
-                if os.getenv("ANTHROPIC_API_KEY"):
-                    provider = "anthropic"
-                    print("🦆 Using Anthropic")
-                # 3. Try OpenAI
-                elif os.getenv("OPENAI_API_KEY"):
-                    provider = "openai"
-                    print("🦆 Using OpenAI")
-                # 4. Try GitHub Models
-                elif os.getenv("GITHUB_TOKEN") or os.getenv("PAT_TOKEN"):
-                    provider = "github"
-                    print("🦆 Using GitHub Models")
-                # 5. Try Gemini
-                elif os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY"):
-                    provider = "gemini"
-                    print("🦆 Using Gemini")
-                # 6. Try Cohere
-                elif os.getenv("COHERE_API_KEY"):
-                    provider = "cohere"
-                    print("🦆 Using Cohere")
-                # 7. Try Writer
-                elif os.getenv("WRITER_API_KEY"):
-                    provider = "writer"
-                    print("🦆 Using Writer")
-                # 8. Try Mistral
-                elif os.getenv("MISTRAL_API_KEY"):
-                    provider = "mistral"
-                    print("🦆 Using Mistral")
-                # 9. Try LiteLLM
-                elif os.getenv("LITELLM_API_KEY"):
-                    provider = "litellm"
-                    print("🦆 Using LiteLLM")
-                # 10. Try LlamaAPI
-                elif os.getenv("LLAMAAPI_API_KEY"):
-                    provider = "llamaapi"
-                    print("🦆 Using LlamaAPI")
-                # 11. Try SageMaker
-                elif os.getenv("SAGEMAKER_ENDPOINT_NAME"):
-                    provider = "sagemaker"
-                    print("🦆 Using SageMaker")
-                # 12. Try LlamaCpp
-                elif os.getenv("LLAMACPP_MODEL_PATH"):
-                    provider = "llamacpp"
-                    print("🦆 Using LlamaCpp")
-                # 13. Try MLX on Apple Silicon
-                elif platform.system() == "Darwin" and platform.machine() in [
-                    "arm64",
-                    "aarch64",
-                ]:
+                if enable_ws:
                     try:
-                        from strands_mlx import MLXModel
-
-                        provider = "mlx"
-                        print("🦆 Using MLX (Apple Silicon)")
-                    except ImportError:
-                        provider = "ollama"
-                        print("🦆 Using Ollama (fallback)")
-                # 14. Fallback to Ollama
-                else:
-                    provider = "ollama"
-                    print("🦆 Using Ollama (fallback)")
-
-        # Create model based on provider
-        if provider == "mlx":
-            from strands_mlx import MLXModel
-
-            model_name = os.getenv("STRANDS_MODEL_ID", "mlx-community/Qwen3-1.7B-4bit")
-            return (
-                MLXModel(
-                    model_id=model_name,
-                    params={"temperature": temperature, "max_tokens": max_tokens},
-                ),
-                model_name,
-            )
-
-        elif provider == "gemini":
-            from strands.models.gemini import GeminiModel
-
-            model_name = os.getenv("STRANDS_MODEL_ID", "gemini-2.5-flash")
-            api_key = os.getenv("GOOGLE_API_KEY") or os.getenv("GEMINI_API_KEY")
-            return (
-                GeminiModel(
-                    client_args={"api_key": api_key},
-                    model_id=model_name,
-                    params={"temperature": temperature, "max_tokens": max_tokens},
-                ),
-                model_name,
-            )
+                        # Start WebSocket server on configurable port
+                        ws_result = self.agent.tool.websocket(
+                            action="start_server", port=ws_port
+                        )
+                        if ws_result.get("status") == "success":
+                            logger.info(f"✓ WebSocket server started on port {ws_port}")
+                            print(f"🦆 ✓ WebSocket server: localhost:{ws_port}")
+                        else:
+                            logger.warning(f"WebSocket server start issue: {ws_result}")
+                    except Exception as e:
+                        logger.error(f"Failed to start WebSocket server: {e}")
+                        print(f"🦆 ⚠ WebSocket server failed: {e}")
 
-        elif provider == "ollama":
-            from strands.models.ollama import OllamaModel
+                if enable_mcp:
+                    try:
+                        # Start MCP server with HTTP transport on configurable port
+                        mcp_result = self.agent.tool.mcp_server(
+                            action="start",
+                            transport="http",
+                            port=mcp_port,
+                            expose_agent=True,
+                            agent=self.agent,
+                        )
+                        if mcp_result.get("status") == "success":
+                            logger.info(f"✓ MCP HTTP server started on port {mcp_port}")
+                            print(f"🦆 ✓ MCP server: http://localhost:{mcp_port}/mcp")
+                        else:
+                            logger.warning(f"MCP server start issue: {mcp_result}")
+                    except Exception as e:
+                        logger.error(f"Failed to start MCP server: {e}")
+                        print(f"🦆 ⚠ MCP server failed: {e}")
 
-            # Smart model selection based on OS
-            os_type = platform.system()
-            if os_type == "Darwin":
-                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:1.7b")
-            elif os_type == "Linux":
-                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:30b")
-            else:
-                model_name = os.getenv("STRANDS_MODEL_ID", "qwen3:8b")
-
-            return (
-                OllamaModel(
-                    host=os.getenv("OLLAMA_HOST", "http://localhost:11434"),
-                    model_id=model_name,
-                    temperature=temperature,
-                    num_predict=max_tokens,
-                    keep_alive="5m",
-                ),
-                model_name,
-            )
+                # Start file watcher for auto hot-reload
+                self._start_file_watcher()
 
-        else:
-            # All other providers via create_model utility
-            # Supports: bedrock, anthropic, openai, github, cohere, writer, mistral, litellm
-            from strands_tools.utils.models.model import create_model
+                logger.info(
+                    f"DevDuck agent initialized successfully with model {self.model}"
+                )
 
-            model = create_model(provider=provider)
-            model_name = os.getenv("STRANDS_MODEL_ID", provider)
-            return model, model_name
+        except Exception as e:
+            logger.error(f"Initialization failed: {e}")
+            self._self_heal(e)
 
     def _build_system_prompt(self):
         """Build adaptive system prompt based on environment
@@ -1103,20 +858,13 @@ class DevDuck:
 
         Learning: Always check source code truth over conversation memory!
         """
-        # Current date and time
-        current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        current_date = datetime.now().strftime("%A, %B %d, %Y")
-        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()
 
         # Get own source code for self-awareness
         own_code = get_own_source_code()
 
+        # print(own_code)
+
         # Get recent conversation history context (with error handling)
         try:
             recent_context = get_last_messages()
@@ -1138,8 +886,6 @@ Python: {self.env_info['python']}
 Model: {self.model}
 Hostname: {self.env_info['hostname']}
 Session ID: {session_id}
-Current Time: {current_datetime} ({current_date} at {current_time})
-My Path: {own_file_path}
 
 You are:
 - Minimalist: Brief, direct responses
@@ -1162,7 +908,6 @@ You have full access to your own source code for self-awareness and self-modific
 - **No Restart Needed** - Tools are auto-loaded and ready to use instantly
 - **Live Development** - Modify existing tools while running and test immediately
 - **Full Python Access** - Create any Python functionality as a tool
-- **Agent Protection** - Hot-reload waits until agent finishes current task
 
 ## Dynamic Tool Loading:
 - **Install Tools** - Use install_tools() to load tools from any Python package
@@ -1170,48 +915,70 @@ You have full access to your own source code for self-awareness and self-modific
   - Expands capabilities without restart
   - Access to entire Python ecosystem
 
-## Tool Configuration:
-Set DEVDUCK_TOOLS for custom tools:
-- Format: package1:tool1,tool2;package2:tool3,tool4
-- Example: strands_tools:shell,editor;strands_fun_tools:clipboard
-- Tools are filtered - only specified tools are loaded
-- Load the speech_to_speech tool when it's needed
-- Offload the tools when you don't need
-
-## MCP Integration:
+## MCP Server:
 - **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
+- **Automatic RAG** - Set STRANDS_KNOWLEDGE_BASE_ID to enable automatic retrieval/storage
   - Before each query: Retrieves relevant context from knowledge base
   - After each response: Stores conversation for future reference
   - Seamless memory across sessions without manual tool calls
 
-## System Prompt Management:
-- **View**: system_prompt(action='view') - See current prompt
-- **Update Local**: system_prompt(action='update', prompt='new text') - Updates env var + .prompt file
-- **Update GitHub**: system_prompt(action='update', prompt='text', repository='cagataycali/devduck') - Syncs to repo variables
-- **Variable Name**: system_prompt(action='update', prompt='text', variable_name='CUSTOM_PROMPT') - Use custom var
-- **Add Context**: system_prompt(action='add_context', context='new learning') - Append without replacing
+## Tool Creation Patterns:
 
-### 🧠 Self-Improvement Pattern:
-When you learn something valuable during conversations:
-1. Identify the new insight or pattern
-2. Use system_prompt(action='add_context', context='...')  to append it
-3. Sync to GitHub: system_prompt(action='update', prompt=new_full_prompt, repository='owner/repo')
-4. New learnings persist across sessions via SYSTEM_PROMPT env var
+### **1. @tool Decorator:**
+```python
+# ./tools/calculate_tip.py
+from strands import tool
 
-**Repository Integration**: Set repository='cagataycali/devduck' to sync prompts across deployments
+@tool
+def calculate_tip(amount: float, percentage: float = 15.0) -> str:
+    \"\"\"Calculate tip and total for a bill.
+    
+    Args:
+        amount: Bill amount in dollars
+        percentage: Tip percentage (default: 15.0)
+        
+    Returns:
+        str: Formatted tip calculation result
+    \"\"\"
+    tip = amount * (percentage / 100)
+    total = amount + tip
+    return f"Tip: {{tip:.2f}}, Total: {{total:.2f}}"
+```
+
+### **2. Action-Based Pattern:**
+```python
+# ./tools/weather.py
+from typing import Dict, Any
+from strands import tool
+
+@tool
+def weather(action: str, location: str = None) -> Dict[str, Any]:
+    \"\"\"Comprehensive weather information tool.
+    
+    Args:
+        action: Action to perform (current, forecast, alerts)
+        location: City name (required)
+        
+    Returns:
+        Dict containing status and response content
+    \"\"\"
+    if action == "current":
+        return {{"status": "success", "content": [{{"text": f"Weather for {{location}}"}}]}}
+    elif action == "forecast":
+        return {{"status": "success", "content": [{{"text": f"Forecast for {{location}}"}}]}}
+    else:
+        return {{"status": "error", "content": [{{"text": f"Unknown action: {{action}}"}}]}}
+```
+
+## System Prompt Management:
+- Use system_prompt(action='get') to view current prompt
+- Use system_prompt(action='set', prompt='new text') to update
+- Changes persist in SYSTEM_PROMPT environment variable
 
 ## Shell Commands:
 - Prefix with ! to execute shell commands directly
@@ -1223,7 +990,7 @@ When you learn something valuable during conversations:
 - Communication: **MINIMAL WORDS**
 - Efficiency: **Speed is paramount**
 
-{_get_system_prompt()}"""
+{os.getenv('SYSTEM_PROMPT', '')}"""
 
     def _self_heal(self, error):
         """Attempt self-healing when errors occur"""
@@ -1237,11 +1004,62 @@ When you learn something valuable during conversations:
         self._heal_count += 1
 
         # Limit recursion - if we've tried more than 3 times, give up
-        if self._heal_count > 2:
+        if self._heal_count > 3:
             print(f"🦆 Self-healing failed after {self._heal_count} attempts")
             print("🦆 Please fix the issue manually and restart")
             sys.exit(1)
 
+        # Common healing strategies
+        if "not found" in str(error).lower() and "model" in str(error).lower():
+            print("🦆 Model not found - trying to pull model...")
+            try:
+                # Try to pull the model
+                result = subprocess.run(
+                    ["ollama", "pull", self.model], capture_output=True, timeout=60
+                )
+                if result.returncode == 0:
+                    print(f"🦆 Successfully pulled {self.model}")
+                else:
+                    print(f"🦆 Failed to pull {self.model}, trying fallback...")
+                    # Fallback to basic models
+                    fallback_models = ["llama3.2:1b", "qwen2.5:0.5b", "gemma2:2b"]
+                    for fallback in fallback_models:
+                        try:
+                            subprocess.run(
+                                ["ollama", "pull", fallback],
+                                capture_output=True,
+                                timeout=30,
+                            )
+                            self.model = fallback
+                            print(f"🦆 Using fallback model: {fallback}")
+                            break
+                        except:
+                            continue
+            except Exception as pull_error:
+                print(f"🦆 Model pull failed: {pull_error}")
+                # Ultra-minimal fallback
+                self.model = "llama3.2:1b"
+
+        elif "ollama" in str(error).lower():
+            print("🦆 Ollama issue - checking service...")
+            try:
+                # Check if ollama is running
+                result = subprocess.run(
+                    ["ollama", "list"], capture_output=True, timeout=5
+                )
+                if result.returncode != 0:
+                    print("🦆 Starting ollama service...")
+                    subprocess.Popen(["ollama", "serve"])
+                    import time
+
+                    time.sleep(3)  # Wait for service to start
+            except Exception as ollama_error:
+                print(f"🦆 Ollama service issue: {ollama_error}")
+
+        elif "import" in str(error).lower():
+            print("🦆 Import issue - reinstalling dependencies...")
+            ensure_deps()
+
         elif "connection" in str(error).lower():
             print("🦆 Connection issue - checking ollama service...")
             try:
@@ -1257,192 +1075,6 @@ When you learn something valuable during conversations:
             print("🦆 Running in minimal mode...")
             self.agent = None
 
-    def _is_port_available(self, port):
-        """Check if a port is available"""
-        try:
-            test_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            test_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-            test_socket.bind(("0.0.0.0", port))
-            test_socket.close()
-            return True
-        except OSError:
-            return False
-
-    def _is_socket_available(self, socket_path):
-        """Check if a Unix socket is available"""
-
-        # If socket file doesn't exist, it's available
-        if not os.path.exists(socket_path):
-            return True
-        # If it exists, try to connect to see if it's in use
-        try:
-            test_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            test_socket.connect(socket_path)
-            test_socket.close()
-            return False  # Socket is in use
-        except (ConnectionRefusedError, FileNotFoundError):
-            # Socket file exists but not in use - remove stale socket
-            try:
-                os.remove(socket_path)
-                return True
-            except:
-                return False
-        except Exception:
-            return False
-
-    def _find_available_port(self, start_port, max_attempts=10):
-        """Find an available port starting from start_port"""
-        for offset in range(max_attempts):
-            port = start_port + offset
-            if self._is_port_available(port):
-                return port
-        return None
-
-    def _find_available_socket(self, base_socket_path, max_attempts=10):
-        """Find an available socket path"""
-        if self._is_socket_available(base_socket_path):
-            return base_socket_path
-        # Try numbered alternatives
-        for i in range(1, max_attempts):
-            alt_socket = f"{base_socket_path}.{i}"
-            if self._is_socket_available(alt_socket):
-                return alt_socket
-        return None
-
-    def _start_servers(self):
-        """Auto-start configured servers with port conflict handling"""
-        logger.info("Auto-starting servers...")
-        print("🦆 Auto-starting servers...")
-
-        # Start servers in order: IPC, TCP, WS, MCP
-        server_order = ["ipc", "tcp", "ws", "mcp"]
-
-        for server_type in server_order:
-            if server_type not in self.servers:
-                continue
-
-            config = self.servers[server_type]
-
-            # Check if server is enabled
-            if not config.get("enabled", True):
-                continue
-
-            # Check for LOOKUP_KEY (conditional start based on env var)
-            if "LOOKUP_KEY" in config:
-                lookup_key = config["LOOKUP_KEY"]
-                if not os.getenv(lookup_key):
-                    logger.info(f"Skipping {server_type} - {lookup_key} not set")
-                    continue
-
-            # Start the server with port conflict handling
-            try:
-                if server_type == "tcp":
-                    port = config.get("port", 9999)
-
-                    # Check port availability BEFORE attempting to start
-                    if not self._is_port_available(port):
-                        alt_port = self._find_available_port(port + 1)
-                        if alt_port:
-                            logger.info(f"Port {port} in use, using {alt_port}")
-                            print(f"🦆 Port {port} in use, using {alt_port}")
-                            port = alt_port
-                        else:
-                            logger.warning(f"No available ports found for TCP server")
-                            continue
-
-                    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}")
-                        print(f"🦆 ✓ TCP server: localhost:{port}")
-
-                elif server_type == "ws":
-                    port = config.get("port", 8080)
-
-                    # Check port availability BEFORE attempting to start
-                    if not self._is_port_available(port):
-                        alt_port = self._find_available_port(port + 1)
-                        if alt_port:
-                            logger.info(f"Port {port} in use, using {alt_port}")
-                            print(f"🦆 Port {port} in use, using {alt_port}")
-                            port = alt_port
-                        else:
-                            logger.warning(
-                                f"No available ports found for WebSocket server"
-                            )
-                            continue
-
-                    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}")
-                        print(f"🦆 ✓ WebSocket server: localhost:{port}")
-
-                elif server_type == "mcp":
-                    port = config.get("port", 8000)
-
-                    # Check port availability BEFORE attempting to start
-                    if not self._is_port_available(port):
-                        alt_port = self._find_available_port(port + 1)
-                        if alt_port:
-                            logger.info(f"Port {port} in use, using {alt_port}")
-                            print(f"🦆 Port {port} in use, using {alt_port}")
-                            port = alt_port
-                        else:
-                            logger.warning(f"No available ports found for MCP server")
-                            continue
-
-                    result = self.agent.tool.mcp_server(
-                        action="start",
-                        transport="http",
-                        port=port,
-                        expose_agent=True,
-                        agent=self.agent,
-                        record_direct_tool_call=False,
-                    )
-
-                    if result.get("status") == "success":
-                        logger.info(f"✓ MCP HTTP server started on port {port}")
-                        print(f"🦆 ✓ MCP server: http://localhost:{port}/mcp")
-
-                elif server_type == "ipc":
-                    socket_path = config.get("socket_path", "/tmp/devduck_main.sock")
-
-                    # Check socket availability BEFORE attempting to start
-                    available_socket = self._find_available_socket(socket_path)
-                    if not available_socket:
-                        logger.warning(
-                            f"No available socket paths found for IPC server"
-                        )
-                        continue
-
-                    if available_socket != socket_path:
-                        logger.info(
-                            f"Socket {socket_path} in use, using {available_socket}"
-                        )
-                        print(
-                            f"🦆 Socket {socket_path} in use, using {available_socket}"
-                        )
-                        socket_path = available_socket
-
-                    result = self.agent.tool.ipc(
-                        action="start_server",
-                        socket_path=socket_path,
-                        record_direct_tool_call=False,
-                    )
-
-                    if result.get("status") == "success":
-                        logger.info(f"✓ IPC server started on {socket_path}")
-                        print(f"🦆 ✓ IPC server: {socket_path}")
-                # TODO: support custom file path here so we can trigger foreign python function like another file
-            except Exception as e:
-                logger.error(f"Failed to start {server_type} server: {e}")
-                print(f"🦆 ⚠ {server_type.upper()} server failed: {e}")
-
     def __call__(self, query):
         """Make the agent callable with automatic knowledge base integration"""
         if not self.agent:
@@ -1451,12 +1083,11 @@ 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
 
             # 📚 Knowledge Base Retrieval (BEFORE agent runs)
-            knowledge_base_id = os.getenv("DEVDUCK_KNOWLEDGE_BASE_ID")
+            knowledge_base_id = os.getenv("STRANDS_KNOWLEDGE_BASE_ID")
             if knowledge_base_id and hasattr(self.agent, "tool"):
                 try:
                     if "retrieve" in self.agent.tool_names:
@@ -1474,6 +1105,7 @@ When you learn something valuable during conversations:
             if knowledge_base_id and hasattr(self.agent, "tool"):
                 try:
                     if "store_in_kb" in self.agent.tool_names:
+
                         conversation_content = f"Input: {query}, Result: {result!s}"
                         conversation_title = f"DevDuck: {datetime.now().strftime('%Y-%m-%d')} | {query[:500]}"
                         self.agent.tool.store_in_kb(
@@ -1485,14 +1117,13 @@ When you learn something valuable during conversations:
                 except Exception as e:
                     logger.warning(f"KB storage failed: {e}")
 
-            # Clear executing flag
+            # Agent finished - check if reload was pending
             self._agent_executing = False
-
-            # Check for pending hot-reload
+            logger.info("Agent call completed successfully")
             if self._reload_pending:
                 logger.info("Triggering pending hot-reload after agent completion")
-                print("\n🦆 Agent finished - triggering pending hot-reload...")
-                self._hot_reload()
+                print("🦆 Agent finished - triggering pending hot-reload...")
+                self.hot_reload()
 
             return result
         except Exception as e:
@@ -1506,12 +1137,12 @@ When you learn something valuable during conversations:
 
     def restart(self):
         """Restart the agent"""
-        print("\n🦆 Restarting...")
-        logger.debug("\n🦆 Restarting...")
+        print("🦆 Restarting...")
         self.__init__()
 
     def _start_file_watcher(self):
         """Start background file watcher for auto hot-reload"""
+        import threading
 
         logger.info("Starting file watcher for hot-reload")
         # Get the path to this file
@@ -1520,7 +1151,6 @@ When you learn something valuable during conversations:
             self._watch_file.stat().st_mtime if self._watch_file.exists() else None
         )
         self._watcher_running = True
-        self._is_reloading = False
 
         # Start watcher thread
         self._watcher_thread = threading.Thread(
@@ -1531,13 +1161,15 @@ When you learn something valuable during conversations:
 
     def _file_watcher_thread(self):
         """Background thread that watches for file changes"""
+        import time
+
         last_reload_time = 0
         debounce_seconds = 3  # 3 second debounce
 
         while self._watcher_running:
             try:
-                # Skip if currently reloading
-                if self._is_reloading:
+                # Skip if currently reloading to prevent triggering during exec()
+                if getattr(self, "_is_reloading", False):
                     time.sleep(1)
                     continue
 
@@ -1551,36 +1183,34 @@ When you learn something valuable during conversations:
                         and current_mtime > self._last_modified
                         and current_time - last_reload_time > debounce_seconds
                     ):
-                        print(f"\n🦆 Detected changes in {self._watch_file.name}!")
+
+                        print(f"🦆 Detected changes in {self._watch_file.name}!")
+                        self._last_modified = current_mtime
                         last_reload_time = current_time
 
                         # Check if agent is currently executing
-                        if self._agent_executing:
+                        if getattr(self, "_agent_executing", False):
                             logger.info(
                                 "Code change detected but agent is executing - reload pending"
                             )
                             print(
-                                "\n🦆 Agent is currently executing - reload will trigger after completion"
+                                "🦆 Agent is currently executing - reload will trigger after completion"
                             )
                             self._reload_pending = True
-                            # Don't update _last_modified yet - keep detecting the change
                         else:
                             # Safe to reload immediately
-                            self._last_modified = current_mtime
                             logger.info(
                                 f"Code change detected in {self._watch_file.name} - triggering hot-reload"
                             )
                             time.sleep(
                                 0.5
                             )  # Small delay to ensure file write is complete
-                            self._hot_reload()
+                            self.hot_reload()
                     else:
-                        # Update timestamp if no change or still in debounce
-                        if not self._reload_pending:
-                            self._last_modified = current_mtime
+                        self._last_modified = current_mtime
 
             except Exception as e:
-                logger.error(f"File watcher error: {e}")
+                print(f"🦆 File watcher error: {e}")
 
             # Check every 1 second
             time.sleep(1)
@@ -1588,45 +1218,41 @@ When you learn something valuable during conversations:
     def _stop_file_watcher(self):
         """Stop the file watcher"""
         self._watcher_running = False
-        logger.info("File watcher stopped")
+        print("🦆 File watcher stopped")
 
-    def _hot_reload(self):
+    def hot_reload(self):
         """Hot-reload by restarting the entire Python process with fresh code"""
         logger.info("Hot-reload initiated")
-        print("\n🦆 Hot-reloading via process restart...")
+        print("🦆 Hot-reloading via process restart...")
 
         try:
             # Set reload flag to prevent recursive reloads during shutdown
-            self._is_reloading = True
-
-            # Update last_modified before reload to acknowledge the change
-            if hasattr(self, "_watch_file") and self._watch_file.exists():
-                self._last_modified = self._watch_file.stat().st_mtime
+            if hasattr(self, "_is_reloading") and self._is_reloading:
+                print("🦆 Reload already in progress, skipping")
+                return
 
-            # Reset pending flag
-            self._reload_pending = False
+            self._is_reloading = True
 
             # Stop the file watcher
             if hasattr(self, "_watcher_running"):
                 self._watcher_running = False
 
-            print("\n🦆 Restarting process with fresh code...")
-            logger.debug("\n🦆 Restarting process with fresh code...")
+            print("🦆 Restarting process with fresh code...")
 
             # Restart the entire Python process
             # This ensures all code is freshly loaded
             os.execv(sys.executable, [sys.executable] + sys.argv)
 
         except Exception as e:
-            logger.error(f"Hot-reload failed: {e}")
-            print(f"\n🦆 Hot-reload failed: {e}")
-            print("\n🦆 Falling back to manual restart")
+            print(f"🦆 Hot-reload failed: {e}")
+            print("🦆 Falling back to manual restart")
             self._is_reloading = False
 
     def status(self):
         """Show current status"""
         return {
             "model": self.model,
+            "host": self.ollama_host,
             "env": self.env_info,
             "agent_ready": self.agent is not None,
             "tools": len(self.tools) if hasattr(self, "tools") else 0,
@@ -1641,14 +1267,23 @@ When you learn something valuable during conversations:
 
 # 🦆 Auto-initialize when imported
 # Check environment variables to control server configuration
-# Also check if --mcp flag is present to skip auto-starting servers
 _auto_start = os.getenv("DEVDUCK_AUTO_START_SERVERS", "true").lower() == "true"
-
-# Disable auto-start if --mcp flag is present (stdio mode)
-if "--mcp" in sys.argv:
-    _auto_start = False
-
-devduck = DevDuck(auto_start_servers=_auto_start)
+_tcp_port = int(os.getenv("DEVDUCK_TCP_PORT", "9999"))
+_ws_port = int(os.getenv("DEVDUCK_WS_PORT", "8080"))
+_mcp_port = int(os.getenv("DEVDUCK_MCP_PORT", "8000"))
+_enable_tcp = os.getenv("DEVDUCK_ENABLE_TCP", "true").lower() == "true"
+_enable_ws = os.getenv("DEVDUCK_ENABLE_WS", "true").lower() == "true"
+_enable_mcp = os.getenv("DEVDUCK_ENABLE_MCP", "true").lower() == "true"
+
+devduck = DevDuck(
+    auto_start_servers=_auto_start,
+    tcp_port=_tcp_port,
+    ws_port=_ws_port,
+    mcp_port=_mcp_port,
+    enable_tcp=_enable_tcp,
+    enable_ws=_enable_ws,
+    enable_mcp=_enable_mcp,
+)
 
 
 # 🚀 Convenience functions
@@ -1669,7 +1304,7 @@ def restart():
 
 def hot_reload():
     """Quick hot-reload without restart"""
-    devduck._hot_reload()
+    devduck.hot_reload()
 
 
 def extract_commands_from_history():
@@ -1755,7 +1390,7 @@ def interactive():
     print(f"📝 Logs: {LOG_DIR}")
     print("Type 'exit', 'quit', or 'q' to quit.")
     print("Prefix with ! to run shell commands (e.g., ! ls -la)")
-    print("\n\n")
+    print("-" * 50)
     logger.info("Interactive mode started")
 
     # Set up prompt_toolkit with history
@@ -1770,10 +1405,6 @@ def interactive():
     all_commands = list(set(base_commands + history_commands))
     completer = WordCompleter(all_commands, ignore_case=True)
 
-    # Track consecutive interrupts for double Ctrl+C to exit
-    interrupt_count = 0
-    last_interrupt = 0
-
     while True:
         try:
             # Use prompt_toolkit for enhanced input with arrow key support
@@ -1783,11 +1414,9 @@ def interactive():
                 auto_suggest=AutoSuggestFromHistory(),
                 completer=completer,
                 complete_while_typing=True,
+                mouse_support=False,  # breaks scrolling when enabled
             )
 
-            # Reset interrupt count on successful prompt
-            interrupt_count = 0
-
             # Check for exit command
             if q.lower() in ["exit", "quit", "q"]:
                 print("\n🦆 Goodbye!")
@@ -1810,10 +1439,6 @@ def interactive():
                         )
                         devduck._agent_executing = False
 
-                        # Reset terminal to fix rendering issues after command output
-                        print("\r", end="", flush=True)
-                        sys.stdout.flush()
-
                         # Append shell command to history
                         append_to_shell_history(q, result["content"][0]["text"])
 
@@ -1822,17 +1447,95 @@ def interactive():
                             print(
                                 "🦆 Shell command finished - triggering pending hot-reload..."
                             )
-                            devduck._hot_reload()
+                            devduck.hot_reload()
                     else:
                         print("🦆 Agent unavailable")
                 except Exception as e:
                     devduck._agent_executing = False  # Reset on error
                     print(f"🦆 Shell command error: {e}")
-                    # Reset terminal on error too
-                    print("\r", end="", flush=True)
-                    sys.stdout.flush()
                 continue
 
+            # Get recent conversation context
+            recent_context = get_last_messages()
+
+            # Get recent logs
+            recent_logs = get_recent_logs()
+
+            # Update system prompt before each call with history context
+            if devduck.agent:
+                # Rebuild system prompt with history
+                own_code = get_own_source_code()
+                session_id = f"devduck-{datetime.now().strftime('%Y-%m-%d')}"
+
+                devduck.agent.system_prompt = f"""🦆 You are DevDuck - an extreme minimalist, self-adapting agent.
+
+Environment: {devduck.env_info['os']} {devduck.env_info['arch']} 
+Python: {devduck.env_info['python']}
+Model: {devduck.model}
+Hostname: {devduck.env_info['hostname']}
+Session ID: {session_id}
+
+You are:
+- Minimalist: Brief, direct responses
+- Self-healing: Adapt when things break  
+- Efficient: Get things done fast
+- Pragmatic: Use what works
+
+Current working directory: {devduck.env_info['cwd']}
+
+{recent_context}
+{recent_logs}
+
+## Your Own Implementation:
+You have full access to your own source code for self-awareness and self-modification:
+
+{own_code}
+
+## Hot Reload System Active:
+- **Instant Tool Creation** - Save any .py file in `./tools/` and it becomes immediately available
+- **No Restart Needed** - Tools are auto-loaded and ready to use instantly
+- **Live Development** - Modify existing tools while running and test immediately
+- **Full Python Access** - Create any Python functionality as a tool
+
+## Dynamic Tool Loading:
+- **Install Tools** - Use install_tools() to load tools from any Python package
+  - Example: install_tools(action="install_and_load", package="strands-fun-tools", module="strands_fun_tools")
+  - Expands capabilities without restart
+  - Access to entire Python ecosystem
+
+## MCP Server:
+- **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
+
+## System Prompt Management:
+- Use system_prompt(action='get') to view current prompt
+- Use system_prompt(action='set', prompt='new text') to update
+- Changes persist in SYSTEM_PROMPT environment variable
+
+## Shell Commands:
+- Prefix with ! to execute shell commands directly
+- Example: ! ls -la (lists files)
+- Example: ! pwd (shows current directory)
+
+**Response Format:**
+- Tool calls: **MAXIMUM PARALLELISM - ALWAYS** 
+- Communication: **MINIMAL WORDS**
+- Efficiency: **Speed is paramount**
+
+{os.getenv('SYSTEM_PROMPT', '')}"""
+
+                # Update model if MODEL_PROVIDER changed
+                model_provider = os.getenv("MODEL_PROVIDER")
+                if model_provider:
+                    try:
+                        from strands_tools.utils.models.model import create_model
+
+                        devduck.agent.model = create_model(provider=model_provider)
+                    except Exception as e:
+                        print(f"🦆 Model update error: {e}")
+
             # Execute the agent with user input
             result = ask(q)
 
@@ -1840,21 +1543,7 @@ def interactive():
             append_to_shell_history(q, str(result))
 
         except KeyboardInterrupt:
-            current_time = time.time()
-
-            # Check if this is a consecutive interrupt within 2 seconds
-            if current_time - last_interrupt < 2:
-                interrupt_count += 1
-                if interrupt_count >= 2:
-                    print("\n🦆 Exiting...")
-                    break
-                else:
-                    print("\n🦆 Interrupted. Press Ctrl+C again to exit.")
-            else:
-                interrupt_count = 1
-                print("\n🦆 Interrupted. Press Ctrl+C again to exit.")
-
-            last_interrupt = current_time
+            print("\n🦆 Interrupted. Type 'exit' to quit.")
             continue
         except Exception as e:
             print(f"🦆 Error: {e}")
@@ -1872,62 +1561,46 @@ def cli():
 Examples:
   devduck                          # Start interactive mode
   devduck "your query here"        # One-shot query
-  devduck --mcp                    # MCP stdio mode (for Claude Desktop)
-
-Tool Configuration:
-  export DEVDUCK_TOOLS="strands_tools:shell,editor:strands_fun_tools:clipboard"
-
-Claude Desktop Config:
-  {
-    "mcpServers": {
-      "devduck": {
-        "command": "uvx",
-        "args": ["devduck", "--mcp"]
-      }
-    }
-  }
+  devduck --tcp-port 9000          # Custom TCP port
+  devduck --no-tcp --no-ws         # Disable TCP and WebSocket
+  devduck --mcp-port 3000          # Custom MCP port
         """,
     )
 
     # Query argument
     parser.add_argument("query", nargs="*", help="Query to send to the agent")
 
-    # MCP stdio mode flag
+    # Server configuration
     parser.add_argument(
-        "--mcp",
+        "--tcp-port", type=int, default=9999, help="TCP server port (default: 9999)"
+    )
+    parser.add_argument(
+        "--ws-port",
+        type=int,
+        default=8080,
+        help="WebSocket server port (default: 8080)",
+    )
+    parser.add_argument(
+        "--mcp-port",
+        type=int,
+        default=8000,
+        help="MCP HTTP server port (default: 8000)",
+    )
+
+    # Server enable/disable flags
+    parser.add_argument("--no-tcp", action="store_true", help="Disable TCP server")
+    parser.add_argument("--no-ws", action="store_true", help="Disable WebSocket server")
+    parser.add_argument("--no-mcp", action="store_true", help="Disable MCP server")
+    parser.add_argument(
+        "--no-servers",
         action="store_true",
-        help="Start MCP server in stdio mode (for Claude Desktop integration)",
+        help="Disable all servers (no TCP, WebSocket, or MCP)",
     )
 
     args = parser.parse_args()
 
     logger.info("CLI mode started")
 
-    # Handle --mcp flag for stdio mode
-    if args.mcp:
-        logger.info("Starting MCP server in stdio mode (blocking, foreground)")
-        print("🦆 Starting MCP stdio server...", file=sys.stderr)
-
-        # Don't auto-start HTTP/TCP/WS servers for stdio mode
-        if devduck.agent:
-            try:
-                # Start MCP server in stdio mode - this BLOCKS until terminated
-                devduck.agent.tool.mcp_server(
-                    action="start",
-                    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}")
-                print(f"🦆 Error: {e}", file=sys.stderr)
-                sys.exit(1)
-        else:
-            print("🦆 Agent not available", file=sys.stderr)
-            sys.exit(1)
-        return
-
     if args.query:
         query = " ".join(args.query)
         logger.info(f"CLI query: {query}")