relay-code 0.1.0__py3-none-any.whl

tools/network/fetch.py

@@ -0,0 +1,72 @@
+from urllib.parse import urlparse
+
+import httpx
+
+from tools.base import Tool, ToolInvocation, ToolKind, ToolResult
+from pydantic import BaseModel, Field
+
+class WebFetchParams(BaseModel):
+
+    url: str = Field(
+        ...,
+        description='URL to fetch (must be http:// or https://)'
+    )
+
+    timeout: int = Field(
+        30,
+        ge=5,
+        le=120,
+        description='Request timeout in seconds (default: 120)'
+    )
+
+class WebFetchTool(Tool):
+    name = 'fetch'
+    description = 'Fetch content from the URL. Returns the response body as text'
+    kind = ToolKind.NETWORK
+    schema = WebFetchParams
+
+    async def execute(self, invocation: ToolInvocation) -> ToolResult:
+        params = WebFetchParams(**invocation.params)
+
+        parsed = urlparse(params.url)
+        if not parsed.scheme or parsed.scheme not in ('http', 'https'):
+            return ToolResult.error_result(
+                f'Url must be http:// or https://'
+            )
+    
+        try:
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(params.timeout),
+                follow_redirects=True,
+            ) as client:
+                response = await client.get(params.url)
+                response.raise_for_status()
+                text = response.text
+        except httpx.HTTPStatusError as e:
+            return ToolResult.error_result(
+                f'HTTP {e.response.status_code}: {e.response.reason_phrase}'
+            )
+        except httpx.TimeoutException:
+            return ToolResult.error_result(
+                f'Request failed: {e}'
+            )
+        except Exception as e:
+            return ToolResult.error_result(
+                f'Search failed: {e}'
+            )
+
+        
+        if len(text) > 100 * 1024:
+            text = text[:100 * 1024] + '\n... [content truncated]'
+
+        return ToolResult.success_result(
+            text,
+            metadata = {
+                'status_code': response.status_code,
+                'content_length': len(response.content),
+            }
+        )
+
+
+
+       

tools/network/search.py

@@ -0,0 +1,72 @@
+from ddgs import DDGS
+
+from tools.base import Tool, ToolInvocation, ToolKind, ToolResult
+from pydantic import BaseModel, Field
+
+class WebSearchParams(BaseModel):
+
+    query: str = Field(
+        ...,
+        description='Search query'
+    )
+
+    max_results: int = Field(
+        10,
+        ge=1,
+        le=50,
+        description='Maximum results to return (default: 10)'
+    )
+
+class WebSearchTool(Tool):
+    name = 'search'
+    description = 'Search the web for information. Returns the search results that contains titles, URL(s) and snippets.'
+    kind = ToolKind.NETWORK
+    schema = WebSearchParams
+
+    async def execute(self, invocation: ToolInvocation) -> ToolResult:
+        params = WebSearchParams(**invocation.params)
+    
+        try:
+            results = DDGS().text(
+                params.query,
+                region='us-en',
+                safesearch='off',
+                timelimit='y',
+                page=1,
+                backend='auto'
+            )
+        except Exception as e:
+            return ToolResult.error_result(
+                f'Search failed: {e}'
+            )
+
+        if not results:
+            return ToolResult.success_result(
+                f'No results found for: {params.query}',
+                metadata = {
+                    'results': 0,
+                }
+            )
+
+        output_lines = [
+            f'Search results for: {params.query}'
+        ]
+
+        for i, result in enumerate(results, start=1):
+            output_lines.append(f"{i}. Title: {result['title']}")
+            output_lines.append(f"     URL: {result['href']}")
+            if result.get('body'):
+                output_lines.append(f"  Snippet: {result['body']}")
+            
+            output_lines.append("")
+        
+        return ToolResult.success_result(
+            '\n'.join(output_lines),
+            metadata = {
+                'results': len(results),
+            }
+        )
+
+
+
+       

tools/registry.py

@@ -0,0 +1,96 @@
+from config.config import Config
+from tools.base import Tool
+from typing import Any
+from pathlib import Path
+from tools.base import ToolResult, ToolInvocation
+from tools.core import ReadFileTool, get_all_core_tools
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+class ToolRegistry:
+
+    def __init__(self):
+        self._tools: dict[str, Tool] = {}
+    
+    def register(self, tool: Tool) -> None:
+        if tool.name in self._tools:
+            logger.warning(f"Overwriting existing tool: {tool.name}")
+        
+        self._tools[tool.name] = tool
+        logger.debug(f"Registered tool: {tool.name}")
+    
+    def unregister(self, name: str) -> bool:
+        if name in self._tools:
+            del self._tools[name]
+            return True
+        
+        return False
+    
+    def get(self, name: str) -> Tool | None:
+        if name in self._tools:
+            return self._tools[name]
+        
+        return None
+    
+    def get_tools(self) -> list[Tool]:
+        tools: list[Tool] = []
+
+        for tool in self._tools.values():
+            tools.append(tool)
+        
+        return tools
+    
+    def get_schemas(self) -> list[dict[str, Any]]:
+        return [tool.to_openai_schema() for tool in self.get_tools()]
+    
+    async def invoke(
+            self,
+            name: str,
+            params: dict[str, Any],
+            cwd: Path | None
+        ) -> ToolResult:
+        tool = self.get(name)
+        if tool is None:
+            return ToolResult.error_result(
+                f"Unknown Tool: {name}",
+                metadata={
+                    'tool_name': name
+                },
+            )
+        
+        validiation_errors = tool.validate_params(params)
+        if validiation_errors:
+            return ToolResult.error_result(
+                f"Invalid paramaters: {'; '.join(validiation_errors)}",
+                metadata={
+                    'tool_name': name,
+                    'validation_errors': validiation_errors
+                }
+            )
+        invocation = ToolInvocation(
+            params=params,
+            cwd=cwd,
+        )
+        try:
+            result = await tool.execute(invocation)
+        except Exception as e:
+            logger.exception(f"Tool {name} raised unexpected error")
+            result = ToolResult.error_result(
+                f"Internal error: {(str(e))}",
+                metadata = {
+                    "tool_name": name
+                }
+            )
+        
+        return result
+        
+def create_default_registery(config: Config) -> ToolRegistry:
+
+    registery = ToolRegistry()
+    
+    for tool_class in get_all_core_tools():
+        registery.register(tool_class(config))
+
+    return registery

ui/__init__.py

@@ -0,0 +1,5 @@
+
+from ui.app import RelayApp
+from ui.renderer import TUI, get_console
+
+__all__ = ['RelayApp', 'TUI', 'get_console']