opencode-agent 0.1.0__py3-none-any.whl

opencode_agent/config.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_BASE_URL = "http://localhost:4096"
+DEFAULT_AGENT = "build"
+DEFAULT_TIMEOUT_SECONDS = 120.0
+DEFAULT_MCP_CONFIG = "mcp.json"
+
+
+def load_environment_file(path: str | Path = ".env") -> None:
+    env_path = Path(path)
+    if not env_path.exists():
+        return
+    for raw_line in env_path.read_text().splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        os.environ.setdefault(key, value)
+
+
+def load_json_file(path: str | Path) -> dict[str, Any]:
+    json_path = Path(path)
+    if not json_path.exists():
+        return {}
+    return json.loads(json_path.read_text())
+
+
+@dataclass(slots=True)
+class RetryPolicy:
+    attempts: int = 3
+    backoff_seconds: float = 0.5
+
+
+@dataclass(slots=True)
+class OpenCodeConfig:
+    base_url: str = DEFAULT_BASE_URL
+    project_path: str = ""
+    default_model: str | None = None
+    default_agent: str = DEFAULT_AGENT
+    streaming: bool = False
+    verbose: bool = False
+    timeout_seconds: float = DEFAULT_TIMEOUT_SECONDS
+    retry_policy: RetryPolicy = field(default_factory=RetryPolicy)
+    default_tools: list[str] = field(default_factory=list)
+    mcp_servers: dict[str, dict[str, Any]] = field(default_factory=dict)
+    mcp_config_path: str = DEFAULT_MCP_CONFIG
+
+    @classmethod
+    def from_env(cls) -> "OpenCodeConfig":
+        load_environment_file(".env")
+        load_environment_file(".environment")
+        base_url = os.getenv("OPENCODE_SERVER") or os.getenv("OPENCODE_BASE_URL") or DEFAULT_BASE_URL
+        project_path = os.getenv("OPENCODE_PROJECT_PATH", "").strip()
+        if not project_path:
+            raise ValueError("OPENCODE_PROJECT_PATH is required in .env")
+        default_model = os.getenv("OPENCODE_MODEL")
+        default_agent = os.getenv("OPENCODE_AGENT", DEFAULT_AGENT)
+        streaming = os.getenv("OPENCODE_STREAMING", "false").lower() == "true"
+        verbose = os.getenv("OPENCODE_VERBOSE", "false").lower() == "true"
+        timeout_seconds = float(os.getenv("OPENCODE_TIMEOUT", str(DEFAULT_TIMEOUT_SECONDS)))
+        attempts = int(os.getenv("OPENCODE_RETRY_ATTEMPTS", "3"))
+        backoff_seconds = float(os.getenv("OPENCODE_RETRY_BACKOFF", "0.5"))
+        tools = [tool for tool in os.getenv("OPENCODE_TOOLS", "").split(",") if tool]
+        mcp_config_path = os.getenv("OPENCODE_MCP_CONFIG", DEFAULT_MCP_CONFIG)
+        mcp_servers = load_json_file(mcp_config_path).get("servers", {})
+        return cls(
+            base_url=base_url,
+            project_path=project_path,
+            default_model=default_model,
+            default_agent=default_agent,
+            streaming=streaming,
+            verbose=verbose,
+            timeout_seconds=timeout_seconds,
+            retry_policy=RetryPolicy(attempts=attempts, backoff_seconds=backoff_seconds),
+            default_tools=tools,
+            mcp_servers=mcp_servers,
+            mcp_config_path=mcp_config_path,
+        )
+
+    @classmethod
+    def from_file(cls, path: str | Path) -> "OpenCodeConfig":
+        data = json.loads(Path(path).read_text())
+        retry_data = data.get("retry_policy", {})
+        return cls(
+            base_url=data.get("base_url", DEFAULT_BASE_URL),
+            project_path=data.get("project_path", ""),
+            default_model=data.get("default_model"),
+            default_agent=data.get("default_agent", DEFAULT_AGENT),
+            streaming=data.get("streaming", False),
+            verbose=data.get("verbose", False),
+            timeout_seconds=data.get("timeout_seconds", DEFAULT_TIMEOUT_SECONDS),
+            retry_policy=RetryPolicy(
+                attempts=retry_data.get("attempts", 3),
+                backoff_seconds=retry_data.get("backoff_seconds", 0.5),
+            ),
+            default_tools=data.get("default_tools", []),
+            mcp_servers=data.get("mcp_servers", {}),
+            mcp_config_path=data.get("mcp_config_path", DEFAULT_MCP_CONFIG),
+        )

opencode_agent/exceptions.py

@@ -0,0 +1,25 @@
+class OpenCodeError(Exception):
+    """Base error for orchestration failures."""
+
+
+class OpenCodeHTTPError(OpenCodeError):
+    def __init__(self, status_code: int, message: str):
+        super().__init__(f"HTTP {status_code}: {message}")
+        self.status_code = status_code
+        self.message = message
+
+
+class SessionNotFoundError(OpenCodeError):
+    """Raised when referencing a session ID that does not exist."""
+
+
+class MCPReadinessError(OpenCodeError):
+    """Raised when a required MCP server is not available and cannot be registered."""
+
+
+class TaskTimeoutError(OpenCodeError):
+    """Raised when a task execution exceeds the configured timeout."""
+
+
+class ToolNotFoundError(OpenCodeError):
+    """Raised when a requested tool is not available on the OpenCode server."""

opencode_agent/logging.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+
+def configure_logging(verbose: bool = False) -> None:
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.INFO,
+        format="%(message)s",
+    )
+
+
+def log_event(logger: logging.Logger, event: str, **payload: Any) -> None:
+    logger.info(json.dumps({"event": event, **payload}, default=str))

opencode_agent/managers.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .client import OpenCodeClient
+from .exceptions import MCPReadinessError, SessionNotFoundError, ToolNotFoundError
+from .models import MCPServer, Session, ToolSchema
+
+
+@dataclass(slots=True)
+class SessionRecord:
+    task_id: str
+    session_id: str
+    parent_session_id: str | None = None
+    title: str | None = None
+
+
+class SessionManager:
+    def __init__(self, client: OpenCodeClient):
+        self.client = client
+        self._registry: dict[str, SessionRecord] = {}
+
+    def create(self, task_id: str, title: str | None = None, parent_session_id: str | None = None) -> Session:
+        session = self.client.create_session(title=title, parent_id=parent_session_id)
+        self._registry[task_id] = SessionRecord(
+            task_id=task_id,
+            session_id=session.id,
+            parent_session_id=parent_session_id,
+            title=title,
+        )
+        return session
+
+    def reuse_or_create(self, task_id: str, session_id: str | None = None, title: str | None = None) -> Session:
+        if session_id:
+            for record in self._registry.values():
+                if record.session_id == session_id:
+                    session = Session(id=session_id, title=title or record.title)
+                    self._registry[task_id] = SessionRecord(task_id=task_id, session_id=session.id, title=session.title)
+                    return session
+            session = self.client.get_session(session_id)
+            self._registry[task_id] = SessionRecord(task_id=task_id, session_id=session.id, title=session.title)
+            return session
+        return self.create(task_id=task_id, title=title)
+
+    def get_record(self, task_id: str) -> SessionRecord:
+        if task_id not in self._registry:
+            raise SessionNotFoundError(f"No session registered for task {task_id}")
+        return self._registry[task_id]
+
+    def link_existing(self, task_id: str, session_id: str, parent_session_id: str | None = None, title: str | None = None) -> None:
+        self._registry[task_id] = SessionRecord(
+            task_id=task_id,
+            session_id=session_id,
+            parent_session_id=parent_session_id,
+            title=title,
+        )
+
+    def fork(self, parent_task_id: str, child_task_id: str, message_id: str | None = None) -> Session:
+        parent = self.get_record(parent_task_id)
+        session = self.client.fork_session(parent.session_id, message_id=message_id)
+        self._registry[child_task_id] = SessionRecord(
+            task_id=child_task_id,
+            session_id=session.id,
+            parent_session_id=parent.session_id,
+            title=session.title,
+        )
+        return session
+
+    def abort(self, task_id: str) -> None:
+        record = self.get_record(task_id)
+        self.client.abort_session(record.session_id)
+
+    def delete(self, task_id: str) -> None:
+        record = self.get_record(task_id)
+        self.client.delete_session(record.session_id)
+        del self._registry[task_id]
+
+    def list_registry(self) -> list[SessionRecord]:
+        return list(self._registry.values())
+
+
+class ToolManager:
+    def __init__(self, client: OpenCodeClient):
+        self.client = client
+        self._tool_ids: list[str] | None = None
+        self._tools_by_model: dict[tuple[str | None, str | None], list[ToolSchema]] = {}
+
+    def get_tool_ids(self, refresh: bool = False) -> list[str]:
+        if refresh or self._tool_ids is None:
+            self._tool_ids = self.client.list_tool_ids()
+        return self._tool_ids
+
+    def get_tools(self, provider: str | None = None, model: str | None = None, refresh: bool = False) -> list[ToolSchema]:
+        cache_key = (provider, model)
+        if refresh or cache_key not in self._tools_by_model:
+            self._tools_by_model[cache_key] = self.client.list_tools(provider=provider, model=model)
+        return self._tools_by_model[cache_key]
+
+    def resolve_allowlist(self, tools: list[str] | None, *, strict: bool = False) -> list[str] | None:
+        """Return tools filtered to those actually available on the OpenCode server.
+
+        Args:
+            tools: list of tool names requested by the caller.
+            strict: if True, raise ToolNotFoundError for any tool not available
+                    on the server instead of silently ignoring it.
+        """
+        if tools is None:
+            return None
+        available = set(self.get_tool_ids())
+        resolved = []
+        missing = []
+        for tool in tools:
+            if tool in available:
+                resolved.append(tool)
+            else:
+                missing.append(tool)
+        if missing and strict:
+            raise ToolNotFoundError(
+                f"The following tools are not available on the OpenCode server: {', '.join(missing)}. "
+                f"Available tools: {', '.join(sorted(available))}"
+            )
+        return resolved if resolved else None
+
+
+class MCPManager:
+    def __init__(self, client: OpenCodeClient):
+        self.client = client
+
+    def list_servers(self) -> list[MCPServer]:
+        return self.client.get_mcp_status()
+
+    def register(self, name: str, config: dict[str, Any]) -> Any:
+        return self.client.register_mcp_server(name=name, config=config)
+
+    def ensure_servers(self, required: list[str], configured_servers: dict[str, dict[str, Any]]) -> list[MCPServer]:
+        available = {server.name: server for server in self.list_servers()}
+        missing = [name for name in required if name not in available]
+        for name in missing:
+            if name not in configured_servers:
+                raise MCPReadinessError(f"Required MCP server '{name}' is unavailable and not configured")
+            self.register(name, configured_servers[name])
+        refreshed = {server.name: server for server in self.list_servers()}
+        still_missing = [name for name in required if name not in refreshed]
+        if still_missing:
+            raise MCPReadinessError(f"Required MCP servers unavailable after registration: {', '.join(still_missing)}")
+        return [refreshed[name] for name in required]

opencode_agent/models.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class MessageInfo:
+    id: str
+    role: str
+    time: int | None = None
+
+
+@dataclass(slots=True)
+class MessagePart:
+    type: str
+    data: dict[str, Any]
+
+    @property
+    def text(self) -> str | None:
+        return self.data.get("text")
+
+
+@dataclass(slots=True)
+class Message:
+    info: MessageInfo
+    parts: list[MessagePart]
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "Message":
+        info = payload.get("info", {})
+        parts = []
+        for part in payload.get("parts", []):
+            part_type = part.get("type", "unknown")
+            parts.append(MessagePart(type=part_type, data=part))
+        return cls(
+            info=MessageInfo(
+                id=info.get("id", ""),
+                role=info.get("role", "assistant"),
+                time=info.get("time"),
+            ),
+            parts=parts,
+        )
+
+    @property
+    def text_output(self) -> str:
+        return "\n".join(part.text for part in self.parts if part.type == "text" and part.text)
+
+    @property
+    def tool_events(self) -> list[dict[str, Any]]:
+        return [part.data for part in self.parts if part.type in {"tool-call", "tool-result", "tool"}]
+
+
+@dataclass(slots=True)
+class Session:
+    id: str
+    title: str | None
+    directory: str | None = None
+    parent_id: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "Session":
+        return cls(
+            id=payload["id"],
+            title=payload.get("title"),
+            directory=payload.get("directory"),
+            parent_id=payload.get("parentID") or payload.get("parent_id"),
+            raw=payload,
+        )
+
+
+@dataclass(slots=True)
+class SessionState:
+    session_id: str
+    status: str
+    active_form: str | None = None
+
+
+@dataclass(slots=True)
+class ToolSchema:
+    name: str
+    description: str | None
+    input_schema: dict[str, Any]
+
+
+@dataclass(slots=True)
+class MCPServer:
+    name: str
+    status: str | None
+    tools: list[str] = field(default_factory=list)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class AgentDefinition:
+    id: str
+    name: str | None = None
+    description: str | None = None
+
+
+@dataclass(slots=True)
+class StreamEvent:
+    type: str
+    payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ExecutionMetadata:
+    task_id: str
+    session_id: str
+    agent: str
+    status: str
+    message_id: str | None = None
+    tool_events: list[dict[str, Any]] = field(default_factory=list)
+    logs: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class ExecutionResult:
+    output: str
+    metadata: ExecutionMetadata
+    message: Message | None = None
+
+
+@dataclass(slots=True)
+class SubtaskTrace:
+    task_id: str
+    session_id: str
+    agent: str
+    prompt: str
+    output: str
+    message_id: str | None
+    status: str
+
+
+@dataclass(slots=True)
+class MultiAgentResult:
+    output: str
+    metadata: ExecutionMetadata
+    trace: list[SubtaskTrace]