iridet-bot 0.1.1a1__py3-none-any.whl

iribot/.env.example

@@ -0,0 +1,4 @@
+OPENAI_API_KEY=your-api-key-here
+OPENAI_MODEL=gpt-4-vision-preview
+OPENAI_BASE_URL=
+DEBUG=False

iribot/__init__.py

@@ -0,0 +1,5 @@
+"""IriBot package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

iribot/__main__.py

@@ -0,0 +1,7 @@
+"""Entrypoint for python -m iribot."""
+
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

iribot/ag_ui_protocol.py

@@ -0,0 +1,247 @@
+"""AG-UI Protocol implementation for chat messages"""
+from typing import Optional, List, Any, Literal, Union
+from dataclasses import dataclass, asdict, field
+from datetime import datetime
+import json
+import uuid
+
+
+@dataclass
+class ToolCall:
+    """Tool function call"""
+    id: str
+    type: Literal["function"] = "function"
+    function: dict = field(default_factory=lambda: {"name": "", "arguments": ""})
+
+    def to_dict(self):
+        return asdict(self)
+
+
+@dataclass
+class BinaryContent:
+    """Binary content (image, file, etc.)"""
+    type: Literal["binary"] = "binary"
+    mimeType: str = "image/jpeg"
+    data: Optional[str] = None  # base64 encoded
+    id: Optional[str] = None
+    url: Optional[str] = None
+    filename: Optional[str] = None
+
+    def to_dict(self):
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+
+@dataclass
+class AGUIMessage:
+    """AG-UI Protocol Message"""
+    id: str
+    role: str  # "user", "assistant", "system", etc.
+    content: Optional[str] = None
+    name: Optional[str] = None
+    tool_calls: List[ToolCall] = field(default_factory=list)
+    tool_results: List[dict] = field(default_factory=list)
+    binary_content: List[BinaryContent] = field(default_factory=list)
+    metadata: dict = field(default_factory=dict)
+
+    @classmethod
+    def from_message(cls, message: dict) -> "AGUIMessage":
+        """Convert chat message to AG-UI format"""
+        msg_id = message.get("id", str(uuid.uuid4()))
+        
+        # Convert legacy 'images' field to binary_content
+        binary_content = message.get("binary_content") or []
+        if not binary_content and message.get("images"):
+            # Auto-convert images to binary_content format
+            binary_content = [
+                BinaryContent(
+                    type="binary",
+                    mimeType="image/jpeg",
+                    data=img,
+                    id=f"img_{i}"
+                ).to_dict()
+                for i, img in enumerate(message.get("images", []))
+            ]
+        
+        # Ensure metadata includes timestamp
+        metadata = message.get("metadata") or {}
+        if "timestamp" not in metadata and message.get("timestamp"):
+            timestamp = message.get("timestamp")
+            if hasattr(timestamp, 'isoformat'):
+                metadata["timestamp"] = timestamp.isoformat()
+            else:
+                metadata["timestamp"] = str(timestamp)
+        
+        return cls(
+            id=msg_id,
+            role=message.get("role", "user"),
+            content=message.get("content"),
+            name=message.get("name"),
+            tool_calls=message.get("tool_calls") or [],
+            tool_results=message.get("tool_results") or [],
+            binary_content=binary_content,
+            metadata=metadata
+        )
+
+    def to_dict(self):
+        """Convert to AG-UI protocol dict"""
+        data = {
+            "id": self.id,
+            "role": self.role,
+        }
+        
+        if self.content:
+            data["content"] = self.content
+        
+        if self.name:
+            data["name"] = self.name
+        
+        if self.tool_calls:
+            data["tool_calls"] = [
+                tc.to_dict() if hasattr(tc, 'to_dict') else tc
+                for tc in self.tool_calls
+            ]
+        
+        if self.tool_results:
+            data["tool_results"] = self.tool_results
+        
+        if self.binary_content:
+            data["binary_content"] = [
+                bc.to_dict() if hasattr(bc, 'to_dict') else bc
+                for bc in self.binary_content
+            ]
+        
+        if self.metadata:
+            data["metadata"] = self.metadata
+        
+        return data
+
+    def to_json(self):
+        """Convert to JSON string"""
+        return json.dumps(self.to_dict())
+
+
+class AGUIEventEncoder:
+    """Encodes and decodes AG-UI protocol events"""
+    
+    @staticmethod
+    def encode_message(message: AGUIMessage) -> str:
+        """Encode AG-UI message to JSON"""
+        return message.to_json()
+    
+    @staticmethod
+    def decode_message(data: str) -> AGUIMessage:
+        """Decode AG-UI message from JSON"""
+        msg_dict = json.loads(data)
+        return AGUIMessage(
+            id=msg_dict.get("id", str(uuid.uuid4())),
+            role=msg_dict.get("role", "user"),
+            content=msg_dict.get("content"),
+            name=msg_dict.get("name"),
+            tool_calls=msg_dict.get("tool_calls", []),
+            tool_results=msg_dict.get("tool_results", []),
+            binary_content=msg_dict.get("binary_content", []),
+            metadata=msg_dict.get("metadata", {})
+        )
+
+    @staticmethod
+    def event_stream(messages: List[dict]) -> List[str]:
+        """Convert messages to AG-UI event stream"""
+        events = []
+        for msg in messages:
+            ag_msg = AGUIMessage.from_message(msg)
+            events.append(ag_msg.to_json())
+        return events
+
+
+def convert_to_ag_ui(message: dict) -> dict:
+    """Helper function to convert message to AG-UI format"""
+    ag_msg = AGUIMessage.from_message(message)
+    return ag_msg.to_dict()
+
+
+def convert_messages_to_ag_ui(messages: List[dict]) -> List[dict]:
+    """Convert list of messages to AG-UI format"""
+    return [convert_to_ag_ui(msg) for msg in messages]
+
+
+@dataclass
+class ToolCallRecordAGUI:
+    """AG-UI format for tool call record"""
+    tool_call_id: str
+    tool_name: str
+    arguments: dict
+    result: Any
+    success: bool
+    timestamp: Optional[str] = None
+
+    def to_dict(self):
+        return {
+            "tool_call_id": self.tool_call_id,
+            "tool_name": self.tool_name,
+            "arguments": self.arguments,
+            "result": self.result,
+            "success": self.success,
+            "timestamp": self.timestamp
+        }
+
+
+@dataclass
+class LLMCallRecordAGUI:
+    """AG-UI format for LLM call record"""
+    id: str
+    request_messages: List[dict]
+    response_content: Optional[str] = None
+    tool_calls: List[dict] = field(default_factory=list)
+    tool_results: List[ToolCallRecordAGUI] = field(default_factory=list)
+    finish_reason: Optional[str] = None
+    timestamp: Optional[str] = None
+
+    def to_dict(self):
+        return {
+            "id": self.id,
+            "request_messages": self.request_messages,
+            "response_content": self.response_content,
+            "tool_calls": self.tool_calls,
+            "tool_results": [
+                tr.to_dict() if hasattr(tr, 'to_dict') else tr
+                for tr in self.tool_results
+            ],
+            "finish_reason": self.finish_reason,
+            "timestamp": self.timestamp
+        }
+
+
+def convert_llm_calls_to_ag_ui(llm_calls: List[dict]) -> List[dict]:
+    """Convert LLM call records to AG-UI format"""
+    result = []
+    for call in llm_calls:
+        tool_results = []
+        if call.get("tool_results"):
+            for tr in call["tool_results"]:
+                timestamp = tr.get("timestamp")
+                if hasattr(timestamp, 'isoformat'):
+                    timestamp = timestamp.isoformat()
+                tool_results.append(ToolCallRecordAGUI(
+                    tool_call_id=tr.get("tool_call_id", ""),
+                    tool_name=tr.get("tool_name", ""),
+                    arguments=tr.get("arguments", {}),
+                    result=tr.get("result"),
+                    success=tr.get("success", False),
+                    timestamp=str(timestamp) if timestamp else None
+                ))
+        
+        timestamp = call.get("timestamp")
+        if hasattr(timestamp, 'isoformat'):
+            timestamp = timestamp.isoformat()
+        
+        ag_call = LLMCallRecordAGUI(
+            id=call.get("id", ""),
+            request_messages=call.get("request_messages", []),
+            response_content=call.get("response_content"),
+            tool_calls=call.get("tool_calls") or [],
+            tool_results=tool_results,
+            finish_reason=call.get("finish_reason"),
+            timestamp=str(timestamp) if timestamp else None
+        )
+        result.append(ag_call.to_dict())
+    return result

iribot/agent.py

@@ -0,0 +1,155 @@
+"""Core Agent logic for handling LLM interactions"""
+
+import json
+from typing import Optional, List, Dict, Any, Generator
+from openai import OpenAI
+from .config import settings
+from .executor import tool_executor
+
+
+class Agent:
+    """Agent for handling LLM interactions"""
+
+    def __init__(self):
+        client_params = {"api_key": settings.openai_api_key}
+        if settings.openai_base_url:
+            client_params["base_url"] = settings.openai_base_url
+
+        self.client = OpenAI(**client_params)
+        self.model = settings.openai_model
+
+    def chat_stream(
+        self,
+        messages: List[Dict[str, Any]],
+        system_prompt: str,
+        images: Optional[List[str]] = None,
+    ) -> Generator[Dict[str, Any], None, None]:
+        """
+        Send a message to the LLM and stream the response
+
+        Yields:
+            Chunks of response data
+        """
+        # Build messages with system prompt
+        formatted_messages = [{"role": "system", "content": system_prompt}]
+
+        # Add image to the last user message if provided
+        if images and messages and messages[-1]["role"] == "user":
+            last_msg = messages[-1].copy()
+            content = [{"type": "text", "text": last_msg.get("content", "")}]
+
+            for image_base64 in images:
+                content.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{image_base64}"
+                        },
+                    }
+                )
+
+            last_msg["content"] = content
+            formatted_messages.extend(messages[:-1])
+            formatted_messages.append(last_msg)
+        else:
+            formatted_messages.extend(messages)
+
+        # Get available tools
+        tools = tool_executor.get_all_tools()
+
+        # Call OpenAI API with streaming
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=formatted_messages,
+            tools=tools,
+            temperature=0.7,
+            stream=True,
+        )
+
+        content = ""
+        tool_calls_data = {}  # {index: {id, function: {name, arguments}}}
+        finish_reason = None
+
+        for chunk in response:
+            delta = chunk.choices[0].delta if chunk.choices else None
+
+            if delta:
+                # Handle content
+                if delta.content:
+                    content += delta.content
+                    yield {"type": "content", "content": delta.content}
+
+                # Handle tool calls
+                if delta.tool_calls:
+                    for tc in delta.tool_calls:
+                        idx = tc.index
+                        if idx not in tool_calls_data:
+                            tool_calls_data[idx] = {
+                                "id": tc.id or "",
+                                "type": "function",
+                                "function": {"name": "", "arguments": ""},
+                            }
+
+                        if tc.id:
+                            tool_calls_data[idx]["id"] = tc.id
+                        if tc.function:
+                            if tc.function.name:
+                                tool_calls_data[idx]["function"][
+                                    "name"
+                                ] = tc.function.name
+                            if tc.function.arguments:
+                                tool_calls_data[idx]["function"][
+                                    "arguments"
+                                ] += tc.function.arguments
+
+            if chunk.choices and chunk.choices[0].finish_reason:
+                finish_reason = chunk.choices[0].finish_reason
+
+        # Yield final result with tool calls
+        tool_calls = (
+            [tool_calls_data[i] for i in sorted(tool_calls_data.keys())]
+            if tool_calls_data
+            else []
+        )
+
+        yield {
+            "type": "done",
+            "content": content.strip(),
+            "tool_calls": tool_calls,
+            "finish_reason": finish_reason,
+        }
+
+    def process_tool_call(
+        self,
+        tool_name: str,
+        arguments: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Process a tool call from the LLM
+
+        Args:
+            tool_name: Name of the tool to call
+            arguments: JSON string of tool arguments
+
+        Returns:
+            Result of tool execution
+        """
+        try:
+            args = json.loads(arguments) if arguments else {}
+            if tool_name.startswith("shell_") and context:
+                if "session_id" not in args and context.get("session_id"):
+                    args["session_id"] = context["session_id"]
+            result = tool_executor.execute_tool(tool_name, **args)
+            return {"success": True, "result": result}
+        except json.JSONDecodeError:
+            return {
+                "success": False,
+                "error": f"Invalid JSON arguments: {arguments}",
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+# Global agent instance
+agent = Agent()

iribot/cli.py

@@ -0,0 +1,33 @@
+"""Command-line interface for running the IriBot backend."""
+
+from __future__ import annotations
+
+import argparse
+import uvicorn
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the IriBot backend server")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["critical", "error", "warning", "info", "debug", "trace"],
+        help="Log level",
+    )
+
+    args = parser.parse_args()
+
+    uvicorn.run(
+        "iribot.main:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        log_level=args.log_level,
+    )
+
+
+if __name__ == "__main__":
+    main()

iribot/config.py

@@ -0,0 +1,45 @@
+"""Configuration for the Agent Application"""
+import sys
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+from pathlib import Path
+import shutil
+
+
+_ENV_PATH = Path.cwd() / ".env"
+_ENV_EXAMPLE_PATH = Path(__file__).parent / ".env.example"
+
+if not _ENV_PATH.exists():
+    shutil.copyfile(_ENV_EXAMPLE_PATH, _ENV_PATH)
+    print(".env was missing, so .env.example has been copied. Please review and update .env with your own settings.")
+    sys.exit(1)
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    model_config = SettingsConfigDict(
+        env_file=_ENV_PATH,
+        case_sensitive=False,
+        extra="ignore"
+    )
+    
+    # OpenAI Configuration
+    openai_api_key: str = ""
+    openai_model: str = "gpt-4-vision-preview"
+    openai_base_url: Optional[str] = None
+    
+    # Application Configuration
+    debug: bool = False
+    app_title: str = "Agent Application"
+    
+    # Shell Configuration
+    bash_path: str = "bash"  # Path to bash executable, defaults to "bash" in PATH
+    
+    # CORS Configuration
+    cors_origins: list = []
+
+print(Settings.model_config)
+
+
+settings = Settings()

iribot/executor.py

@@ -0,0 +1,73 @@
+"""Tool executor and registry"""
+from typing import Any, Dict, List
+from .tools.base import BaseTool, BaseToolGroup, BaseStatus
+from .tools.execute_command import ShellToolGroup, ShellStatus
+from .tools.read_file import ReadFileTool
+from .tools.write_file import WriteFileTool
+from .tools.list_directory import ListDirectoryTool
+
+
+class ToolExecutor:
+    """Manages and executes tools"""
+    
+    def __init__(self):
+        self.tools: Dict[str, BaseTool] = {}
+        self.statuses: Dict[str, BaseStatus] = {}
+        self._register_default_tools()
+    
+    def _register_default_tools(self) -> None:
+        """Register all default tools"""
+        default_tools = [
+            ReadFileTool(),
+            WriteFileTool(),
+            ListDirectoryTool(),
+        ]
+        for tool in default_tools:
+            self.register_tool(tool)
+
+        self.register_tool_group(ShellToolGroup())
+        self.register_status(ShellStatus())
+    
+    def register_tool(self, tool: BaseTool) -> None:
+        """Register a new tool"""
+        self.tools[tool.name] = tool
+
+    def register_tool_group(self, group: BaseToolGroup) -> None:
+        """Register a group of tools"""
+        tools = group.get_tools()
+        for tool in tools:
+            self.register_tool(tool)
+
+    def register_status(self, status: BaseStatus) -> None:
+        """Register a status-only entry"""
+        self.statuses[status.name] = status
+    
+    def execute_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
+        """Execute a registered tool"""
+        if tool_name not in self.tools:
+            return {
+                "success": False,
+                "error": f"Tool '{tool_name}' not found"
+            }
+        
+        try:
+            tool = self.tools[tool_name]
+            result = tool.execute(**kwargs)
+            return result
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e)
+            }
+    
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """Get all registered tools in OpenAI format"""
+        return [tool.to_dict() for tool in self.tools.values()]
+
+    def get_all_tool_statuses(self) -> List[Dict[str, Any]]:
+        """Get status for all registered tools"""
+        return [status.get_status() for status in self.statuses.values()]
+
+
+# Global tool executor instance
+tool_executor = ToolExecutor()