devduck 0.5.0__py3-none-any.whl → 0.5.2__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.0'
-__version_tuple__ = version_tuple = (0, 5, 0)
+__version__ = version = '0.5.2'
+__version_tuple__ = version_tuple = (0, 5, 2)
 
 __commit_id__ = commit_id = None

devduck/agentcore_handler.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""DevDuck AgentCore Handler"""
+import json
+import os
+import threading
+from bedrock_agentcore.runtime import BedrockAgentCoreApp
+
+# Configure for AgentCore deployment
+os.environ["DEVDUCK_AUTO_START_SERVERS"] = "false"
+os.environ["MODEL_PROVIDER"] = "bedrock"
+
+from devduck import devduck
+
+app = BedrockAgentCoreApp()
+
+
+@app.entrypoint
+async def invoke(payload, context):
+    """AgentCore entrypoint - streaming by default with async generator"""
+    mode = payload.get("mode", "streaming")  # streaming (default), sync, async
+
+    query = payload.get("prompt", payload.get("text", ""))
+    if not query:
+        yield {"error": "No query provided"}
+        return
+
+    print(f"Mode: {mode}, Query: {query}")
+
+    agent = devduck.agent
+
+    if mode == "sync":
+        # Sync mode - return result directly (blocking)
+        try:
+            result = agent(query)
+            yield {"statusCode": 200, "response": str(result)}
+        except Exception as e:
+            print(f"Error in sync: {str(e)}")
+            yield {"statusCode": 500, "error": str(e)}
+
+    elif mode == "async":
+        # Async mode - fire and forget in background thread
+        task_id = app.add_async_task("devduck_processing", payload)
+        thread = threading.Thread(
+            target=lambda: _run_in_thread(agent, query, task_id), daemon=True
+        )
+        thread.start()
+        yield {"statusCode": 200, "task_id": task_id}
+
+    else:
+        # Streaming mode (default) - stream events as they happen
+        try:
+            stream = agent.stream_async(query)
+            async for event in stream:
+                print(event)
+                yield event
+        except Exception as e:
+            print(f"Error in streaming: {str(e)}")
+            yield {"error": str(e)}
+
+
+def _run_in_thread(agent, query, task_id):
+    """Run agent in background thread for async mode"""
+    try:
+        result = agent(query)
+        print(f"DevDuck result: {result}")
+        app.complete_async_task(task_id)
+    except Exception as e:
+        print(f"Error in async thread: {str(e)}")
+        try:
+            app.complete_async_task(task_id)
+        except:
+            pass
+
+
+if __name__ == "__main__":
+    app.run()

devduck/tools/__init__.py

@@ -5,5 +5,48 @@ from .mcp_server import mcp_server
 from .install_tools import install_tools
 from .tray import tray
 from .ambient import ambient
+from .websocket import websocket
+from .ipc import ipc
+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
 
-__all__ = ["tcp", "mcp_server", "install_tools", "tray", "ambient"]
+# AgentCore tools (conditionally available)
+try:
+    from .agentcore_config import agentcore_config
+    from .agentcore_invoke import agentcore_invoke
+    from .agentcore_logs import agentcore_logs
+    from .agentcore_agents import agentcore_agents
+
+    __all__ = [
+        "tcp",
+        "websocket",
+        "ipc",
+        "mcp_server",
+        "install_tools",
+        "use_github",
+        "create_subagent",
+        "store_in_kb",
+        "system_prompt",
+        "tray",
+        "ambient",
+        "agentcore_config",
+        "agentcore_invoke",
+        "agentcore_logs",
+        "agentcore_agents",
+    ]
+except ImportError:
+    __all__ = [
+        "tcp",
+        "websocket",
+        "ipc",
+        "mcp_server",
+        "install_tools",
+        "use_github",
+        "create_subagent",
+        "store_in_kb",
+        "system_prompt",
+        "tray",
+        "ambient",
+    ]

devduck/tools/_tray_app.py

@@ -83,6 +83,14 @@ class DevDuckTray(rumps.App):
         """Build menu with server controls and agent capabilities"""
         self.menu.clear()
 
+        # Test Button - First item for easy testing
+        self.menu.add(
+            rumps.MenuItem(
+                "🧪 Test Agent", callback=self._create_callback("what time is it?")
+            )
+        )
+        self.menu.add(rumps.separator)
+
         # Active Streams Section
         if self.active_streams:
             self.menu.add(rumps.MenuItem("🌊 Active Streams", callback=None))

devduck/tools/agentcore_agents.py

@@ -0,0 +1,197 @@
+"""AgentCore Agents Tool - List and manage deployed DevDuck agents."""
+
+import json
+from typing import Any, Dict, Optional
+from strands import tool
+
+
+@tool
+def agentcore_agents(
+    action: str = "list",
+    agent_id: Optional[str] = None,
+    agent_name: Optional[str] = None,
+    max_results: int = 100,
+    region: str = "us-west-2",
+) -> Dict[str, Any]:
+    """Manage and discover Bedrock AgentCore agent runtimes.
+
+    Args:
+        action: Agent operation (list, get, find_by_name)
+        agent_id: Agent runtime ID (for "get" action)
+        agent_name: Agent name to search (for "find_by_name")
+        max_results: Max results for list (default: 100)
+        region: AWS region (default: us-west-2)
+
+    Returns:
+        Dict with status and agent information
+
+    Examples:
+        # List all agents
+        agentcore_agents(action="list")
+
+        # Get specific agent
+        agentcore_agents(action="get", agent_id="devduck-UrvQvkH6H7")
+
+        # Find by name
+        agentcore_agents(action="find_by_name", agent_name="devduck")
+    """
+    try:
+        import boto3
+        from botocore.exceptions import ClientError
+
+        client = boto3.client("bedrock-agentcore-control", region_name=region)
+
+        if action == "list":
+            all_agents = []
+            next_token = None
+
+            while True:
+                params = {"maxResults": min(max_results - len(all_agents), 100)}
+                if next_token:
+                    params["nextToken"] = next_token
+
+                response = client.list_agent_runtimes(**params)
+                agents = response.get("agentRuntimes", [])
+                all_agents.extend(agents)
+
+                if len(all_agents) >= max_results:
+                    all_agents = all_agents[:max_results]
+                    break
+
+                next_token = response.get("nextToken")
+                if not next_token:
+                    break
+
+            # Format output
+            agent_list = []
+            for agent in all_agents:
+                agent_list.append(
+                    {
+                        "name": agent.get("agentRuntimeName"),
+                        "id": agent.get("agentRuntimeId"),
+                        "arn": agent.get("agentRuntimeArn"),
+                        "created": str(agent.get("createdAt")),
+                        "updated": str(agent.get("lastUpdatedAt")),
+                    }
+                )
+
+            return {
+                "status": "success",
+                "content": [
+                    {"text": f"**Found {len(agent_list)} agents:**\n"},
+                    {"text": json.dumps(agent_list, indent=2)},
+                ],
+            }
+
+        elif action == "get":
+            if not agent_id:
+                return {
+                    "status": "error",
+                    "content": [{"text": "agent_id required for get action"}],
+                }
+
+            response = client.get_agent_runtime(agentRuntimeId=agent_id)
+
+            agent_info = {
+                "id": response.get("agentRuntimeId"),
+                "arn": response.get("agentRuntimeArn"),
+                "name": response.get("agentRuntimeName"),
+                "status": response.get("status"),
+                "roleArn": response.get("roleArn"),
+                "created": str(response.get("createdAt")),
+                "updated": str(response.get("lastUpdatedAt")),
+            }
+
+            # Add container info
+            if "agentRuntimeArtifact" in response:
+                container = response["agentRuntimeArtifact"].get(
+                    "containerConfiguration", {}
+                )
+                if container:
+                    agent_info["containerUri"] = container.get("containerUri")
+
+            # Add network info
+            if "networkConfiguration" in response:
+                agent_info["networkMode"] = response["networkConfiguration"].get(
+                    "networkMode"
+                )
+
+            return {
+                "status": "success",
+                "content": [
+                    {"text": "**Agent Details:**\n"},
+                    {"text": json.dumps(agent_info, indent=2)},
+                ],
+            }
+
+        elif action == "find_by_name":
+            if not agent_name:
+                return {
+                    "status": "error",
+                    "content": [
+                        {"text": "agent_name required for find_by_name action"}
+                    ],
+                }
+
+            # List and search
+            all_agents = []
+            next_token = None
+
+            while True:
+                params = {"maxResults": 100}
+                if next_token:
+                    params["nextToken"] = next_token
+
+                response = client.list_agent_runtimes(**params)
+                agents = response.get("agentRuntimes", [])
+                all_agents.extend(agents)
+
+                next_token = response.get("nextToken")
+                if not next_token:
+                    break
+
+            # Find match
+            matching = None
+            for agent in all_agents:
+                if agent.get("agentRuntimeName") == agent_name:
+                    matching = agent
+                    break
+
+            if matching:
+                return {
+                    "status": "success",
+                    "content": [
+                        {"text": f"✅ **Found: {agent_name}**\n"},
+                        {"text": json.dumps(matching, indent=2, default=str)},
+                    ],
+                }
+            else:
+                return {
+                    "status": "error",
+                    "content": [{"text": f"Agent not found: {agent_name}"}],
+                }
+
+        else:
+            return {
+                "status": "error",
+                "content": [
+                    {
+                        "text": f"Unknown action: {action}. Valid: list, get, find_by_name"
+                    }
+                ],
+            }
+
+    except ClientError as e:
+        error_code = e.response.get("Error", {}).get("Code", "Unknown")
+        error_message = e.response.get("Error", {}).get("Message", str(e))
+
+        return {
+            "status": "error",
+            "content": [
+                {"text": f"**AWS Error ({error_code}):** {error_message}"},
+                {"text": f"**Region:** {region}"},
+            ],
+        }
+
+    except Exception as e:
+        return {"status": "error", "content": [{"text": f"Error: {str(e)}"}]}