devorch 0.1.2__py3-none-any.whl

providers/openai.py

@@ -0,0 +1,114 @@
+import json
+
+from openai import OpenAI
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class OpenAIProvider(LLMProvider):
+    name = "openai"
+
+    DEFAULT_MODELS = [
+        "gpt-4o",
+        "gpt-4o-mini",
+        "gpt-4-turbo",
+        "gpt-4",
+        "gpt-3.5-turbo",
+        "o1-preview",
+        "o1-mini",
+    ]
+
+    def __init__(self, model: str = "gpt-4o", api_key: str | None = None):
+        self.client = OpenAI(api_key=api_key)
+        self.model = model
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from OpenAI API."""
+        try:
+            response = self.client.models.list()
+            models = []
+            # Filter to chat models
+            chat_prefixes = ("gpt-4", "gpt-3.5", "o1")
+            for model in response.data:
+                if any(model.id.startswith(p) for p in chat_prefixes):
+                    models.append(
+                        ModelInfo(
+                            id=model.id,
+                            name=model.id,
+                        )
+                    )
+            # Sort by name
+            models.sort(key=lambda m: m.id)
+            return models if models else [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+        except Exception:
+            return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Format messages for OpenAI
+        formatted_messages = []
+        for msg in messages:
+            if msg.role == "tool":
+                formatted_msg = {
+                    "role": "tool",
+                    "content": msg.content,
+                    "tool_call_id": msg.tool_call_id or msg.name,
+                }
+            elif msg.role == "assistant" and msg.metadata and msg.metadata.get("tool_calls"):
+                # Preserve tool_calls in assistant messages
+                formatted_msg = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": msg.metadata["tool_calls"],
+                }
+            else:
+                formatted_msg = {"role": msg.role, "content": msg.content}
+            formatted_messages.append(formatted_msg)
+
+        # Format tools for OpenAI
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool.get(
+                                "parameters", {"type": "object", "properties": {}}
+                            ),
+                        },
+                    }
+                )
+
+        response = self.client.chat.completions.create(
+            model=self.model, messages=formatted_messages, tools=formatted_tools, temperature=0.0
+        )
+
+        choice = response.choices[0]
+        message = choice.message
+
+        tool_calls = []
+        if message.tool_calls:
+            for tc in message.tool_calls:
+                # OpenAI returns arguments as a JSON string
+                args = json.loads(tc.function.arguments) if tc.function.arguments else {}
+
+                tool_call = ToolCall(name=tc.function.name, arguments=args, id=tc.id)
+                tool_calls.append(tool_call)
+
+        # Handle case where assistant message has no content but has tool calls
+        content = message.content if message.content else "Calling tool..."
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=response,
+        )

providers/openrouter.py

@@ -0,0 +1,195 @@
+"""
+OpenRouter Provider - Access multiple models through one API.
+https://openrouter.ai/
+"""
+
+import json
+
+import httpx
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class OpenRouterProvider(LLMProvider):
+    """
+    OpenRouter provides access to many models through a single API.
+    Supports: Claude, GPT-4, Llama, Mistral, and many more.
+    """
+
+    name = "openrouter"
+
+    DEFAULT_MODELS = [
+        "anthropic/claude-sonnet-4",
+        "anthropic/claude-3.5-sonnet",
+        "openai/gpt-4o",
+        "openai/gpt-4o-mini",
+        "meta-llama/llama-3.3-70b-instruct",
+        "google/gemini-2.0-flash-001",
+        "mistralai/mistral-large-2411",
+        "deepseek/deepseek-chat-v3-0324",
+    ]
+
+    BASE_URL = "https://openrouter.ai/api/v1"
+
+    def __init__(
+        self,
+        model: str = "anthropic/claude-3.5-sonnet",
+        api_key: str | None = None,
+        site_url: str = "https://github.com/Amanbig/DevOrch",
+        site_name: str = "DevOrch",
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.site_url = site_url
+        self.site_name = site_name
+        self.client = httpx.Client(timeout=120.0)
+
+    def _get_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "HTTP-Referer": self.site_url,
+            "X-Title": self.site_name,
+            "Content-Type": "application/json",
+        }
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from OpenRouter API."""
+        try:
+            response = self.client.get(f"{self.BASE_URL}/models", headers=self._get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+            models = []
+            for model in data.get("data", []):
+                model_id = model.get("id", "")
+                # Skip models that don't support chat or are deprecated
+                architecture = model.get("architecture", {})
+                if architecture.get("modality") == "text->image":
+                    continue  # Skip image generation models
+
+                models.append(
+                    ModelInfo(
+                        id=model_id,
+                        name=model.get("name", model_id),
+                        context_length=model.get("context_length"),
+                        description=model.get("description"),
+                    )
+                )
+
+            # Sort by name, prioritizing well-known providers
+            def sort_key(m):
+                priority_prefixes = [
+                    "openai/",
+                    "anthropic/",
+                    "google/",
+                    "meta-llama/",
+                    "mistralai/",
+                    "deepseek/",
+                ]
+                for i, prefix in enumerate(priority_prefixes):
+                    if m.id.startswith(prefix):
+                        return (i, m.name)
+                return (len(priority_prefixes), m.name)
+
+            models.sort(key=sort_key)
+            return models if models else [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+        except Exception:
+            return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Format messages for OpenRouter API
+        formatted_messages = []
+        for msg in messages:
+            if msg.role == "tool":
+                formatted_msg = {
+                    "role": "tool",
+                    "content": msg.content,
+                    "tool_call_id": msg.tool_call_id or msg.name,
+                }
+            elif msg.role == "assistant" and msg.metadata and msg.metadata.get("tool_calls"):
+                # Preserve tool_calls in assistant messages
+                formatted_msg = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": msg.metadata["tool_calls"],
+                }
+            else:
+                formatted_msg = {"role": msg.role, "content": msg.content}
+            formatted_messages.append(formatted_msg)
+
+        # Format tools (OpenAI-compatible format)
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool.get(
+                                "parameters", {"type": "object", "properties": {}}
+                            ),
+                        },
+                    }
+                )
+
+        payload = {
+            "model": self.model,
+            "messages": formatted_messages,
+            "temperature": 0.0,
+        }
+
+        if formatted_tools:
+            payload["tools"] = formatted_tools
+
+        response = self.client.post(
+            f"{self.BASE_URL}/chat/completions", headers=self._get_headers(), json=payload
+        )
+
+        # Handle errors with better messages
+        if response.status_code == 404:
+            raise Exception(
+                f"Model '{self.model}' not found on OpenRouter. Try /model to select a different model."
+            )
+        elif response.status_code == 401:
+            raise Exception("Invalid OpenRouter API key. Please check your API key.")
+        elif response.status_code == 402:
+            raise Exception("OpenRouter credits exhausted. Please add credits to your account.")
+
+        response.raise_for_status()
+        data = response.json()
+
+        choice = data["choices"][0]
+        message = choice["message"]
+
+        tool_calls = []
+        if message.get("tool_calls"):
+            for tc in message["tool_calls"]:
+                args = (
+                    json.loads(tc["function"]["arguments"])
+                    if tc["function"].get("arguments")
+                    else {}
+                )
+                tool_call = ToolCall(
+                    name=tc["function"]["name"],
+                    arguments=args,
+                    id=tc.get("id", tc["function"]["name"]),
+                )
+                tool_calls.append(tool_call)
+
+        content = message.get("content") or "Calling tool..."
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=data,
+        )

providers/together.py

@@ -0,0 +1,159 @@
+"""
+Together AI Provider - Open source models at scale
+https://together.ai/
+"""
+
+import json
+
+import httpx
+
+from providers.base import LLMProvider, ModelInfo
+from schemas.message import LLMResponse, Message, ToolCall
+
+
+class TogetherProvider(LLMProvider):
+    """
+    Together AI provider for open source models.
+    Supports Llama, Mistral, Code Llama, and more.
+    """
+
+    name = "together"
+
+    DEFAULT_MODELS = [
+        "meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo",
+        "mistralai/Mixtral-8x22B-Instruct-v0.1",
+        "mistralai/Mistral-7B-Instruct-v0.3",
+        "Qwen/Qwen2-72B-Instruct",
+        "deepseek-ai/deepseek-coder-33b-instruct",
+    ]
+
+    BASE_URL = "https://api.together.xyz/v1"
+
+    def __init__(
+        self,
+        model: str = "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
+        api_key: str | None = None,
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.client = httpx.Client(timeout=120.0)
+
+    def _get_headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def list_models(self) -> list[ModelInfo]:
+        """Fetch available models from Together API."""
+        try:
+            response = self.client.get(f"{self.BASE_URL}/models", headers=self._get_headers())
+            response.raise_for_status()
+            data = response.json()
+
+            models = []
+            # Filter to chat/instruct models
+            for model in data:
+                model_id = model.get("id", "")
+                model_type = model.get("type", "")
+                if "chat" in model_type.lower() or "instruct" in model_id.lower():
+                    models.append(
+                        ModelInfo(
+                            id=model_id,
+                            name=model.get("display_name", model_id),
+                            context_length=model.get("context_length"),
+                        )
+                    )
+
+            models.sort(key=lambda m: m.name)
+            return models[:50] if models else [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+        except Exception:
+            return [ModelInfo(id=m, name=m) for m in self.DEFAULT_MODELS]
+
+    def generate(
+        self,
+        messages: list[Message],
+        tools: list | None = None,
+        stream: bool = False,
+    ) -> LLMResponse:
+        # Format messages for Together API
+        formatted_messages = []
+        for msg in messages:
+            if msg.role == "tool":
+                formatted_msg = {
+                    "role": "tool",
+                    "content": msg.content,
+                    "tool_call_id": msg.tool_call_id or msg.name,
+                }
+            elif msg.role == "assistant" and msg.metadata and msg.metadata.get("tool_calls"):
+                # Preserve tool_calls in assistant messages
+                formatted_msg = {
+                    "role": "assistant",
+                    "content": msg.content or "",
+                    "tool_calls": msg.metadata["tool_calls"],
+                }
+            else:
+                formatted_msg = {"role": msg.role, "content": msg.content}
+            formatted_messages.append(formatted_msg)
+
+        # Format tools
+        formatted_tools = None
+        if tools:
+            formatted_tools = []
+            for tool in tools:
+                formatted_tools.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool["name"],
+                            "description": tool["description"],
+                            "parameters": tool.get(
+                                "parameters", {"type": "object", "properties": {}}
+                            ),
+                        },
+                    }
+                )
+
+        payload = {
+            "model": self.model,
+            "messages": formatted_messages,
+            "temperature": 0.0,
+        }
+
+        if formatted_tools:
+            payload["tools"] = formatted_tools
+
+        response = self.client.post(
+            f"{self.BASE_URL}/chat/completions", headers=self._get_headers(), json=payload
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        choice = data["choices"][0]
+        message = choice["message"]
+
+        tool_calls = []
+        if message.get("tool_calls"):
+            for tc in message["tool_calls"]:
+                args = (
+                    json.loads(tc["function"]["arguments"])
+                    if tc["function"].get("arguments")
+                    else {}
+                )
+                tool_call = ToolCall(
+                    name=tc["function"]["name"],
+                    arguments=args,
+                    id=tc.get("id", tc["function"]["name"]),
+                )
+                tool_calls.append(tool_call)
+
+        content = message.get("content") or "Calling tool..."
+
+        return LLMResponse(
+            message=Message(role="assistant", content=content),
+            tool_calls=tool_calls if tool_calls else None,
+            raw=data,
+        )

schemas/message.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ToolCall:
+    name: str
+    arguments: dict[str, Any]
+    id: str | None = None
+
+
+@dataclass
+class Message:
+    role: str  # "system" | "user" | "tool" | "assistant"
+    content: str
+    name: str | None = None
+    tool_call_id: str | None = None
+    metadata: dict[str, Any] | None = None
+
+
+@dataclass
+class Tool:
+    name: str
+    description: str
+    arguments: dict[str, Any] = None
+
+
+@dataclass
+class LLMResponse:
+    message: Message
+    tool_calls: list[ToolCall] | None = None
+    raw: Any | None = None

schemas/task.py

@@ -0,0 +1,115 @@
+"""Task schema for tracking work progress."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+
+
+class TaskStatus(str, Enum):
+    """Status of a task."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+
+
+@dataclass
+class Task:
+    """A single task to track."""
+
+    content: str  # What needs to be done (imperative form)
+    status: TaskStatus = TaskStatus.PENDING
+    id: str | None = None
+    active_form: str | None = None  # Present continuous form (e.g., "Running tests")
+    created_at: datetime = field(default_factory=datetime.now)
+    completed_at: datetime | None = None
+
+    def to_dict(self) -> dict:
+        """Convert task to dictionary."""
+        return {
+            "id": self.id,
+            "content": self.content,
+            "status": self.status.value,
+            "active_form": self.active_form,
+            "created_at": self.created_at.isoformat(),
+            "completed_at": self.completed_at.isoformat() if self.completed_at else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Task":
+        """Create task from dictionary."""
+        return cls(
+            id=data.get("id"),
+            content=data["content"],
+            status=TaskStatus(data.get("status", "pending")),
+            active_form=data.get("active_form") or data.get("activeForm"),
+            created_at=datetime.fromisoformat(data["created_at"])
+            if data.get("created_at")
+            else datetime.now(),
+            completed_at=datetime.fromisoformat(data["completed_at"])
+            if data.get("completed_at")
+            else None,
+        )
+
+
+@dataclass
+class TaskList:
+    """A list of tasks."""
+
+    tasks: list[Task] = field(default_factory=list)
+
+    def add(self, task: Task) -> Task:
+        """Add a task to the list."""
+        if not task.id:
+            task.id = f"task_{len(self.tasks) + 1}"
+        self.tasks.append(task)
+        return task
+
+    def get(self, task_id: str) -> Task | None:
+        """Get a task by ID."""
+        for task in self.tasks:
+            if task.id == task_id:
+                return task
+        return None
+
+    def update_status(self, task_id: str, status: TaskStatus) -> Task | None:
+        """Update a task's status."""
+        task = self.get(task_id)
+        if task:
+            task.status = status
+            if status == TaskStatus.COMPLETED:
+                task.completed_at = datetime.now()
+        return task
+
+    def get_by_status(self, status: TaskStatus) -> list[Task]:
+        """Get all tasks with a specific status."""
+        return [t for t in self.tasks if t.status == status]
+
+    def get_current(self) -> Task | None:
+        """Get the current in-progress task."""
+        in_progress = self.get_by_status(TaskStatus.IN_PROGRESS)
+        return in_progress[0] if in_progress else None
+
+    def clear(self):
+        """Clear all tasks."""
+        self.tasks = []
+
+    @property
+    def pending_count(self) -> int:
+        return len(self.get_by_status(TaskStatus.PENDING))
+
+    @property
+    def in_progress_count(self) -> int:
+        return len(self.get_by_status(TaskStatus.IN_PROGRESS))
+
+    @property
+    def completed_count(self) -> int:
+        return len(self.get_by_status(TaskStatus.COMPLETED))
+
+    @property
+    def total_count(self) -> int:
+        return len(self.tasks)
+
+    def to_list(self) -> list[dict]:
+        """Convert to list of dictionaries."""
+        return [t.to_dict() for t in self.tasks]

tools/__init__.py

@@ -0,0 +1,30 @@
+"""
+DevOrch Tools - Tools for interacting with the system.
+
+Available tools:
+- ShellTool: Execute shell commands
+- OpenTerminalTool: Run a command in a new terminal window (servers, scaffolds, long-running processes)
+- TerminalSessionTool: Managed background sessions with read/send/stop/list
+- FilesystemTool: Read, write, list files with line-specific control
+- SearchTool: Find files by glob patterns
+- GrepTool: Search file contents with regex
+- EditTool: Make targeted edits to files
+"""
+
+from tools.edit import EditTool
+from tools.filesystem import FilesystemTool
+from tools.grep import GrepTool
+from tools.search import SearchTool
+from tools.shell import ShellTool
+from tools.terminal import OpenTerminalTool
+from tools.terminal_session import TerminalSessionTool
+
+__all__ = [
+    "ShellTool",
+    "OpenTerminalTool",
+    "TerminalSessionTool",
+    "FilesystemTool",
+    "SearchTool",
+    "GrepTool",
+    "EditTool",
+]

tools/base.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class Tool(ABC):
+    """
+    Base class for all tools.
+    """
+
+    name: str = ""
+    description: str = ""
+    args_schema: type[BaseModel] = None
+
+    @abstractmethod
+    def run(self, arguments: dict[str, Any]) -> Any:
+        """
+        Execute the tool with given arguments.
+        """
+        pass
+
+    def schema(self) -> dict[str, Any]:
+        """
+        JSON schema exposed to LLMs.
+        """
+        parameters = {"type": "object", "properties": {}}
+        if self.args_schema:
+            schema_dump = self.args_schema.model_json_schema()
+            parameters = {
+                "type": "object",
+                "properties": schema_dump.get("properties", {}),
+                "required": schema_dump.get("required", []),
+            }
+
+        return {
+            "name": self.name,
+            "description": self.description,
+            "parameters": parameters,
+        }