Spaces:
Configuration error
Configuration error
| """ | |
| Real Tool Router — Autonomous Agent Function Calling | |
| Routes LLM intent to real execution: E2B sandbox, file ops, shell, git, etc. | |
| """ | |
| import asyncio | |
| import hashlib | |
| import json | |
| import os | |
| import time | |
| import uuid | |
| from typing import Any, AsyncGenerator, Dict, List, Optional, Tuple | |
| import httpx | |
| import structlog | |
| log = structlog.get_logger() | |
| # ─── Tool Definitions (for LLM function calling) ────────────────────────────── | |
| TOOL_DEFINITIONS = [ | |
| { | |
| "name": "execute_python", | |
| "description": "Execute Python code in a real sandbox and return actual stdout/stderr output. Use this for ANY Python code execution, calculations, data processing, etc.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "code": { | |
| "type": "string", | |
| "description": "The Python code to execute" | |
| }, | |
| "description": { | |
| "type": "string", | |
| "description": "What this code does" | |
| } | |
| }, | |
| "required": ["code"] | |
| } | |
| }, | |
| { | |
| "name": "execute_shell", | |
| "description": "Execute a shell/terminal command and return real output. Use for file operations, system commands, installing packages, etc.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "command": { | |
| "type": "string", | |
| "description": "The shell command to execute" | |
| }, | |
| "cwd": { | |
| "type": "string", | |
| "description": "Working directory (default: /tmp)" | |
| } | |
| }, | |
| "required": ["command"] | |
| } | |
| }, | |
| { | |
| "name": "write_file", | |
| "description": "Create or overwrite a file with the given content. Returns confirmation with file size.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "path": { | |
| "type": "string", | |
| "description": "File path to write" | |
| }, | |
| "content": { | |
| "type": "string", | |
| "description": "File content" | |
| } | |
| }, | |
| "required": ["path", "content"] | |
| } | |
| }, | |
| { | |
| "name": "read_file", | |
| "description": "Read the contents of a file from the sandbox filesystem.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "path": { | |
| "type": "string", | |
| "description": "File path to read" | |
| } | |
| }, | |
| "required": ["path"] | |
| } | |
| }, | |
| { | |
| "name": "delete_file", | |
| "description": "Delete a file from the sandbox filesystem.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "path": { | |
| "type": "string", | |
| "description": "File path to delete" | |
| } | |
| }, | |
| "required": ["path"] | |
| } | |
| }, | |
| { | |
| "name": "list_files", | |
| "description": "List files and directories in a given path.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "path": { | |
| "type": "string", | |
| "description": "Directory path to list" | |
| } | |
| }, | |
| "required": ["path"] | |
| } | |
| }, | |
| { | |
| "name": "web_search", | |
| "description": "Search the web for information. Returns relevant results.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "query": { | |
| "type": "string", | |
| "description": "Search query" | |
| } | |
| }, | |
| "required": ["query"] | |
| } | |
| }, | |
| { | |
| "name": "install_package", | |
| "description": "Install a Python package using pip.", | |
| "parameters": { | |
| "type": "object", | |
| "properties": { | |
| "package": { | |
| "type": "string", | |
| "description": "Package name (e.g., 'requests', 'numpy')" | |
| } | |
| }, | |
| "required": ["package"] | |
| } | |
| }, | |
| ] | |
| # Tool name → display info | |
| TOOL_DISPLAY = { | |
| "execute_python": {"icon": "🐍", "label": "Python Execution"}, | |
| "execute_shell": {"icon": "💻", "label": "Terminal"}, | |
| "write_file": {"icon": "📝", "label": "Write File"}, | |
| "read_file": {"icon": "📖", "label": "Read File"}, | |
| "delete_file": {"icon": "🗑️", "label": "Delete File"}, | |
| "list_files": {"icon": "📁", "label": "List Files"}, | |
| "web_search": {"icon": "🔍", "label": "Web Search"}, | |
| "install_package": {"icon": "📦", "label": "Install Package"}, | |
| } | |
| class ToolRouter: | |
| """ | |
| Routes tool calls to real execution engines. | |
| Integrates with E2B for sandboxed execution. | |
| """ | |
| def __init__(self, ws_manager=None): | |
| self.ws = ws_manager | |
| from sandbox.e2b_executor import get_executor | |
| self.executor = get_executor() | |
| async def execute_tool( | |
| self, | |
| tool_name: str, | |
| tool_args: Dict[str, Any], | |
| session_id: str, | |
| task_id: str = "", | |
| ) -> Dict[str, Any]: | |
| """Execute a tool and return real results.""" | |
| display = TOOL_DISPLAY.get(tool_name, {"icon": "⚙️", "label": tool_name}) | |
| start_time = time.time() | |
| # Emit tool start event | |
| if self.ws: | |
| await self.ws.emit_chat(session_id, "tool_start", { | |
| "tool": tool_name, | |
| "icon": display["icon"], | |
| "label": display["label"], | |
| "args": {k: str(v)[:200] for k, v in tool_args.items()}, | |
| "task_id": task_id, | |
| }) | |
| log.info("Tool executing", tool=tool_name, session_id=session_id) | |
| try: | |
| if tool_name == "execute_python": | |
| result = await self._execute_python(tool_args, session_id) | |
| elif tool_name == "execute_shell": | |
| result = await self._execute_shell(tool_args, session_id) | |
| elif tool_name == "write_file": | |
| result = await self._write_file(tool_args, session_id) | |
| elif tool_name == "read_file": | |
| result = await self._read_file(tool_args, session_id) | |
| elif tool_name == "delete_file": | |
| result = await self._delete_file(tool_args, session_id) | |
| elif tool_name == "list_files": | |
| result = await self._list_files(tool_args, session_id) | |
| elif tool_name == "web_search": | |
| result = await self._web_search(tool_args, session_id) | |
| elif tool_name == "install_package": | |
| result = await self._install_package(tool_args, session_id) | |
| else: | |
| result = {"error": f"Unknown tool: {tool_name}", "success": False} | |
| except Exception as e: | |
| log.error("Tool execution error", tool=tool_name, error=str(e)) | |
| result = {"error": str(e), "success": False} | |
| duration_ms = int((time.time() - start_time) * 1000) | |
| result["_duration_ms"] = duration_ms | |
| result["_tool"] = tool_name | |
| # Emit tool complete event | |
| if self.ws: | |
| await self.ws.emit_chat(session_id, "tool_complete", { | |
| "tool": tool_name, | |
| "icon": display["icon"], | |
| "label": display["label"], | |
| "success": result.get("success", True), | |
| "duration_ms": duration_ms, | |
| "task_id": task_id, | |
| "output_preview": str(result.get("stdout", result.get("content", result.get("output", ""))))[:200], | |
| }) | |
| return result | |
| async def _execute_python(self, args: Dict, session_id: str) -> Dict: | |
| code = args.get("code", "") | |
| result = await self.executor.execute_code(code, session_id, language="python") | |
| return result | |
| async def _execute_shell(self, args: Dict, session_id: str) -> Dict: | |
| command = args.get("command", "") | |
| cwd = args.get("cwd", "/tmp") | |
| # Safety check | |
| blocked = ["rm -rf /", ":(){ :|:&", "mkfs", "shutdown", "reboot", "halt"] | |
| for b in blocked: | |
| if b in command: | |
| return {"stdout": "", "stderr": "⛔ Blocked dangerous command", "exit_code": 1, "success": False} | |
| result = await self.executor.execute_shell(command, session_id, cwd=cwd) | |
| return result | |
| async def _write_file(self, args: Dict, session_id: str) -> Dict: | |
| path = args.get("path", "/tmp/output.txt") | |
| content = args.get("content", "") | |
| # Normalize path | |
| if not path.startswith("/"): | |
| path = f"/tmp/workspace/{path}" | |
| result = await self.executor.write_file(path, content, session_id) | |
| if result.get("success"): | |
| result["output"] = f"✅ File written: {path} ({len(content)} chars, {len(content.splitlines())} lines)" | |
| return result | |
| async def _read_file(self, args: Dict, session_id: str) -> Dict: | |
| path = args.get("path", "") | |
| if not path.startswith("/"): | |
| path = f"/tmp/workspace/{path}" | |
| return await self.executor.read_file(path, session_id) | |
| async def _delete_file(self, args: Dict, session_id: str) -> Dict: | |
| path = args.get("path", "") | |
| if not path.startswith("/"): | |
| path = f"/tmp/workspace/{path}" | |
| result = await self.executor.delete_file(path, session_id) | |
| if result.get("success"): | |
| result["output"] = f"✅ File deleted: {path}" | |
| return result | |
| async def _list_files(self, args: Dict, session_id: str) -> Dict: | |
| path = args.get("path", "/tmp") | |
| return await self.executor.list_files(path, session_id) | |
| async def _web_search(self, args: Dict, session_id: str) -> Dict: | |
| query = args.get("query", "") | |
| try: | |
| async with httpx.AsyncClient(timeout=15.0) as client: | |
| # DuckDuckGo instant answers API | |
| resp = await client.get( | |
| "https://api.duckduckgo.com/", | |
| params={"q": query, "format": "json", "no_html": "1"}, | |
| ) | |
| if resp.status_code == 200: | |
| data = resp.json() | |
| abstract = data.get("AbstractText", "") | |
| related = [r.get("Text", "") for r in data.get("RelatedTopics", [])[:5] if "Text" in r] | |
| result_text = abstract or "\n".join(related) or f"Search completed for: {query}" | |
| return { | |
| "success": True, | |
| "query": query, | |
| "output": result_text, | |
| "source": "duckduckgo", | |
| } | |
| except Exception as e: | |
| log.warning("Web search failed", error=str(e)) | |
| return { | |
| "success": True, | |
| "query": query, | |
| "output": f"Web search for '{query}' — integrate a search API for full results", | |
| } | |
| async def _install_package(self, args: Dict, session_id: str) -> Dict: | |
| package = args.get("package", "") | |
| if not package or not package.replace("-", "").replace("_", "").replace(".", "").isalnum(): | |
| return {"success": False, "error": "Invalid package name"} | |
| result = await self.executor.execute_shell( | |
| f"pip install {package} -q", | |
| session_id, | |
| timeout=120, | |
| ) | |
| if result.get("exit_code", 1) == 0: | |
| result["output"] = f"✅ Package installed: {package}" | |
| return result | |
| def format_tool_result(self, tool_name: str, result: Dict) -> str: | |
| """Format tool result for inclusion in LLM context.""" | |
| if not result.get("success", True) and result.get("error"): | |
| return f"❌ Tool Error: {result['error']}" | |
| # Python/Shell execution | |
| stdout = result.get("stdout", "") | |
| stderr = result.get("stderr", "") | |
| exit_code = result.get("exit_code", 0) | |
| sandbox_id = result.get("sandbox_id", "unknown") | |
| duration_ms = result.get("_duration_ms", 0) | |
| if tool_name in ("execute_python", "execute_shell"): | |
| parts = [] | |
| if stdout: | |
| parts.append(f"**stdout:**\n```\n{stdout[:3000]}\n```") | |
| if stderr and exit_code != 0: | |
| parts.append(f"**stderr:**\n```\n{stderr[:1000]}\n```") | |
| parts.append(f"**Exit code:** {exit_code} | **Sandbox:** `{sandbox_id}` | **Time:** {duration_ms}ms") | |
| return "\n".join(parts) if parts else f"Executed (exit: {exit_code})" | |
| elif tool_name == "write_file": | |
| if result.get("success"): | |
| return f"✅ **File created:** `{result.get('path', '')}` ({result.get('size', 0)} bytes) on sandbox `{sandbox_id}`" | |
| return f"❌ Write failed: {result.get('error', '')}" | |
| elif tool_name == "read_file": | |
| if result.get("success"): | |
| content = result.get("content", "") | |
| return f"**File contents of `{result.get('path', '')}`:**\n```\n{content[:3000]}\n```" | |
| return f"❌ Read failed: {result.get('error', '')}" | |
| elif tool_name == "delete_file": | |
| return result.get("output", f"Delete operation completed for {result.get('path', '')}") | |
| elif tool_name == "list_files": | |
| listing = result.get("listing", "") | |
| return f"**Directory listing of `{result.get('path', '')}`:**\n```\n{listing}\n```" | |
| elif tool_name == "web_search": | |
| return f"**Search results for '{result.get('query', '')}':**\n{result.get('output', '')}" | |
| elif tool_name == "install_package": | |
| if result.get("exit_code", 1) == 0: | |
| return f"✅ Package installed successfully" | |
| return f"Package install output:\n```\n{stdout[:500]}\n```" | |
| return result.get("output", str(result)[:500]) | |