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

devduck/_version.py

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

devduck/tools/__init__.py

@@ -11,6 +11,7 @@ from .use_github import use_github
 from .create_subagent import create_subagent
 from .store_in_kb import store_in_kb
 from .system_prompt import system_prompt
+from .state_manager import state_manager
 
 # AgentCore tools (conditionally available)
 try:
@@ -29,6 +30,7 @@ try:
         "create_subagent",
         "store_in_kb",
         "system_prompt",
+        "state_manager",
         "tray",
         "ambient",
         "agentcore_config",
@@ -47,6 +49,7 @@ except ImportError:
         "create_subagent",
         "store_in_kb",
         "system_prompt",
+        "state_manager",
         "tray",
         "ambient",
     ]

devduck/tools/agentcore_config.py

@@ -1,4 +1,5 @@
 """AgentCore Configuration and Launch Tool"""
+
 import os
 import subprocess
 from pathlib import Path

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/tools/ipc.py

@@ -322,8 +322,11 @@ def handle_ipc_client(client_socket, client_id, system_prompt: str, socket_path:
                         )
                         continue
 
+    except BrokenPipeError:
+        # Normal disconnect - client closed connection
+        logger.debug(f"IPC client {client_id} disconnected")
     except Exception as e:
-        logger.error(f"Error handling IPC client {client_id}: {e}", exc_info=True)
+        logger.error(f"Error handling IPC client {client_id}: {e}")
     finally:
         try:
             client_socket.close()

devduck/tools/state_manager.py

@@ -0,0 +1,292 @@
+"""DevDuck State Manager - Time-travel for agent conversations"""
+
+import os
+import tempfile
+import dill
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any
+from strands import tool
+
+base_dir = Path(os.getenv("DEVDUCK_HOME", tempfile.gettempdir()))
+states_dir = base_dir / ".devduck" / "states"
+states_dir.mkdir(parents=True, exist_ok=True)
+
+
+@tool
+def state_manager(
+    action: str,
+    state_file: str = None,
+    query: str = None,
+    metadata: dict = None,
+    agent=None,  # Parent agent injection
+) -> Dict[str, Any]:
+    """Agent state management with time-travel capabilities.
+
+    Inspired by cagataycali/research-agent state export pattern.
+
+    Actions:
+    - export: Save current agent state to pkl
+    - load: Load and display state from pkl
+    - list: List available saved states
+    - resume: Load state and continue with new query (ephemeral)
+    - modify: Update pkl file metadata
+    - delete: Remove saved state
+
+    Args:
+        action: Operation to perform
+        state_file: Path to pkl file (auto-generated for export)
+        query: New query for resume action
+        metadata: Additional metadata for export/modify
+        agent: Parent agent (auto-injected by Strands)
+
+    Returns:
+        Dict with status and content
+
+    Examples:
+        # Save current state
+        state_manager(action="export", metadata={"note": "before refactor"})
+
+        # List saved states
+        state_manager(action="list")
+
+        # Resume from previous state (ephemeral, no mutation)
+        state_manager(action="resume", state_file="~/.devduck/states/devduck_20250116_032000.pkl", query="continue analysis")
+
+        # Modify state metadata
+        state_manager(action="modify", state_file="path/to/state.pkl", metadata={"tags": ["important", "refactor"]})
+    """
+    try:
+        if action == "export":
+            # Capture current agent state
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            state_file = states_dir / f"devduck_{timestamp}.pkl"
+
+            # Safe state extraction (avoid complex objects)
+            state_data = {
+                "version": "1.0",
+                "timestamp": datetime.now().isoformat(),
+                "system_prompt": agent.system_prompt,
+                "tools": list(agent.tool_names),
+                "model": {
+                    "model_id": getattr(agent.model, "model_id", "unknown"),
+                    "temperature": getattr(agent.model, "temperature", None),
+                    "provider": getattr(agent.model, "provider", "unknown"),
+                },
+                "metadata": metadata or {},
+                "environment": {
+                    "cwd": str(Path.cwd()),
+                    "devduck_version": "0.6.0",
+                },
+            }
+
+            # Try to capture conversation history if available
+            if hasattr(agent, "conversation_history"):
+                state_data["conversation_history"] = agent.conversation_history
+            elif hasattr(agent, "messages"):
+                state_data["conversation_history"] = agent.messages
+
+            # Save with dill
+            with open(state_file, "wb") as f:
+                dill.dump(state_data, f)
+
+            size = state_file.stat().st_size
+            return {
+                "status": "success",
+                "content": [
+                    {
+                        "text": f"✅ State exported: {state_file}\n"
+                        f"📦 Size: {size} bytes\n"
+                        f"🔧 Tools: {len(state_data['tools'])}\n"
+                        f"📝 Metadata: {metadata or 'none'}"
+                    }
+                ],
+            }
+
+        elif action == "list":
+            # List all saved states
+            states = sorted(
+                states_dir.glob("devduck_*.pkl"),
+                key=lambda p: p.stat().st_mtime,
+                reverse=True,
+            )
+
+            if not states:
+                return {
+                    "status": "success",
+                    "content": [{"text": "No saved states found"}],
+                }
+
+            output = f"📚 Found {len(states)} saved states:\n\n"
+            for i, state_path in enumerate(states[:10], 1):  # Show last 10
+                try:
+                    with open(state_path, "rb") as f:
+                        state_data = dill.load(f)
+
+                    timestamp = state_data.get("timestamp", "unknown")
+                    tools_count = len(state_data.get("tools", []))
+                    meta = state_data.get("metadata", {})
+
+                    output += f"{i}. {state_path.name}\n"
+                    output += f"   📅 {timestamp}\n"
+                    output += f"   🔧 {tools_count} tools\n"
+                    if meta:
+                        output += f"   📝 {meta}\n"
+                    output += "\n"
+                except:
+                    output += f"{i}. {state_path.name} (corrupted)\n\n"
+
+            return {"status": "success", "content": [{"text": output}]}
+
+        elif action == "load":
+            # Load and display state
+            if not state_file:
+                return {
+                    "status": "error",
+                    "content": [{"text": "state_file required for load"}],
+                }
+
+            state_path = Path(state_file).expanduser()
+            if not state_path.exists():
+                return {
+                    "status": "error",
+                    "content": [{"text": f"State file not found: {state_path}"}],
+                }
+
+            with open(state_path, "rb") as f:
+                state_data = dill.load(f)
+
+            # Pretty format
+            output = f"📦 State: {state_path.name}\n\n"
+            output += f"📅 Timestamp: {state_data.get('timestamp')}\n"
+            output += f"🤖 Model: {state_data.get('model', {}).get('model_id')}\n"
+            output += f"🔧 Tools ({len(state_data.get('tools', []))}): {', '.join(state_data.get('tools', []))}\n"
+            output += f"📝 Metadata: {state_data.get('metadata', {})}\n"
+
+            if "conversation_history" in state_data:
+                history = state_data["conversation_history"]
+                output += f"\n💬 Conversation: {len(history)} messages\n"
+
+            return {"status": "success", "content": [{"text": output}]}
+
+        elif action == "resume":
+            # Time-travel: Load state and continue with ephemeral agent
+            if not state_file or not query:
+                return {
+                    "status": "error",
+                    "content": [{"text": "state_file and query required for resume"}],
+                }
+
+            state_path = Path(state_file).expanduser()
+            if not state_path.exists():
+                return {
+                    "status": "error",
+                    "content": [{"text": f"State file not found: {state_path}"}],
+                }
+
+            with open(state_path, "rb") as f:
+                state_data = dill.load(f)
+
+            # ✅ Create ephemeral DevDuck instance (no mutation!)
+            try:
+                from devduck import DevDuck
+
+                ephemeral_duck = DevDuck(auto_start_servers=False)
+                ephemeral_agent = ephemeral_duck.agent
+            except Exception as e:
+                return {
+                    "status": "error",
+                    "content": [{"text": f"Failed to create ephemeral DevDuck: {e}"}],
+                }
+
+            # Load saved state into ephemeral agent
+            ephemeral_agent.system_prompt = state_data["system_prompt"]
+
+            # Restore conversation history
+            if "conversation_history" in state_data:
+                saved_history = state_data["conversation_history"]
+
+                if hasattr(ephemeral_agent, "conversation_history"):
+                    ephemeral_agent.conversation_history = saved_history
+                elif hasattr(ephemeral_agent, "messages"):
+                    ephemeral_agent.messages = saved_history
+
+            # Build continuation prompt with context
+            continuation_context = f"""
+[Resumed from state: {state_path.name}]
+[Original timestamp: {state_data.get('timestamp')}]
+
+{query}
+"""
+            # Run ephemeral agent (parent agent unchanged!)
+            result = ephemeral_agent(continuation_context)
+
+            return {
+                "status": "success",
+                "content": [{"text": f"🔄 Resumed from {state_path.name}\n\n{result}"}],
+            }
+
+        elif action == "modify":
+            # Modify state metadata
+            if not state_file:
+                return {
+                    "status": "error",
+                    "content": [{"text": "state_file required for modify"}],
+                }
+
+            state_path = Path(state_file).expanduser()
+            if not state_path.exists():
+                return {
+                    "status": "error",
+                    "content": [{"text": f"State file not found: {state_path}"}],
+                }
+
+            with open(state_path, "rb") as f:
+                state_data = dill.load(f)
+
+            # Update metadata
+            if metadata:
+                state_data["metadata"].update(metadata)
+
+            # Save back
+            with open(state_path, "wb") as f:
+                dill.dump(state_data, f)
+
+            return {
+                "status": "success",
+                "content": [
+                    {
+                        "text": f"✅ Modified {state_path.name}\n📝 New metadata: {state_data['metadata']}"
+                    }
+                ],
+            }
+
+        elif action == "delete":
+            # Delete saved state
+            if not state_file:
+                return {
+                    "status": "error",
+                    "content": [{"text": "state_file required for delete"}],
+                }
+
+            state_path = Path(state_file).expanduser()
+            if not state_path.exists():
+                return {
+                    "status": "error",
+                    "content": [{"text": f"State file not found: {state_path}"}],
+                }
+
+            state_path.unlink()
+            return {
+                "status": "success",
+                "content": [{"text": f"🗑️  Deleted {state_path.name}"}],
+            }
+
+        else:
+            return {
+                "status": "error",
+                "content": [{"text": f"Unknown action: {action}"}],
+            }
+
+    except Exception as e:
+        return {"status": "error", "content": [{"text": f"Error: {e}"}]}

devduck/tools/tcp.py

@@ -316,6 +316,12 @@ def run_server(
                 if SERVER_THREADS[port]["running"]:
                     logger.error(f"Error accepting connection: {e}")
 
+    except OSError as e:
+        # Port conflict - handled upstream, no need for scary errors
+        if "Address already in use" in str(e):
+            logger.debug(f"Port {port} unavailable (handled upstream)")
+        else:
+            logger.error(f"Server error on {host}:{port}: {e}")
     except Exception as e:
         logger.error(f"Server error on {host}:{port}: {e}")
     finally:

devduck/tools/websocket.py

@@ -347,8 +347,14 @@ def run_websocket_server(
         asyncio.set_event_loop(loop)
         WS_SERVER_THREADS[port]["loop"] = loop
         loop.run_until_complete(start_server())
+    except OSError as e:
+        # Port conflict - handled upstream, no need for scary errors
+        if "Address already in use" in str(e) or "address already in use" in str(e):
+            logger.debug(f"Port {port} unavailable (handled upstream)")
+        else:
+            logger.error(f"WebSocket server error on {host}:{port}: {e}")
     except Exception as e:
-        logger.error(f"WebSocket server error on {host}:{port}: {e}", exc_info=True)
+        logger.error(f"WebSocket server error on {host}:{port}: {e}")
     finally:
         logger.info(f"WebSocket Server on {host}:{port} stopped")
         WS_SERVER_THREADS[port]["running"] = False