opencode-py 0.1.0__py3-none-any.whl

opencode/_async_opencode.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, AsyncIterator, Dict, Optional
+
+from opencode._async_client import AsyncOpendcodeClient
+from opencode._async_session import AsyncSession
+from opencode._models import SessionMessage
+from opencode._opencode import _extract_text, _resolve_model
+from opencode._server import OpencodeServer, create_opencode_server
+
+_async_opencode_state: Dict[str, Any] = {}
+
+
+class AsyncOpendcode:
+    def __init__(
+        self,
+        *,
+        model: Optional[str] = None,
+        hostname: str = "127.0.0.1",
+        port: int = 4096,
+        directory: Optional[str] = None,
+        workspace: Optional[str] = None,
+        server_timeout: float = 30.0,
+        client_timeout: float = 300.0,
+        config: Optional[Dict[str, Any]] = None,
+        opencode_binary: Optional[str] = None,
+    ):
+        self._model = model
+        self._hostname = hostname
+        self._port = port
+        self._directory = directory
+        self._workspace = workspace
+        self._server_timeout = server_timeout
+        self._client_timeout = client_timeout
+        self._config = config
+        self._opencode_binary = opencode_binary
+
+        self._server: Optional[OpencodeServer] = None
+        self._client: Optional[AsyncOpendcodeClient] = None
+
+    # ------------------------------------------------------------------
+    # Async context manager
+    # ------------------------------------------------------------------
+
+    async def __aenter__(self) -> AsyncOpendcode:
+        self.start()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.close()
+
+    # ------------------------------------------------------------------
+    # Server / Client lifecycle
+    # ------------------------------------------------------------------
+
+    def start(self) -> None:
+        if self._client is not None:
+            return
+        server = create_opencode_server(
+            hostname=self._hostname,
+            port=self._port,
+            timeout=self._server_timeout,
+            config=self._config,
+            opencode_binary=self._opencode_binary,
+        )
+        client = AsyncOpendcodeClient(
+            base_url=server.url,
+            directory=self._directory,
+            workspace=self._workspace,
+            timeout=self._client_timeout,
+        )
+        self._server = server
+        self._client = client
+
+    async def close(self) -> None:
+        if self._client:
+            await self._client.close()
+            self._client = None
+        if self._server:
+            self._server.close()
+            self._server = None
+
+    @property
+    def client(self) -> AsyncOpendcodeClient:
+        assert self._client is not None
+        return self._client
+
+    @property
+    def server(self) -> OpencodeServer:
+        assert self._server is not None
+        return self._server
+
+    # ------------------------------------------------------------------
+    # High-level API
+    # ------------------------------------------------------------------
+
+    async def create_session(self, agent: Optional[str] = None, **kwargs) -> AsyncSession:
+        if agent:
+            kwargs["agent"] = agent
+        raw = await self.client.session_create(**kwargs)
+        sid = raw["id"]
+        return AsyncSession(self.client, sid)
+
+    async def ask(
+        self,
+        prompt: str,
+        *,
+        files: Optional[Dict[str, Any]] = None,
+        auto_tools: bool = False,
+        agent: Optional[str] = None,
+        format: Optional[Dict[str, Any]] = None,
+        wait: bool = True,
+        poll_interval: float = 0.5,
+        poll_timeout: float = 600.0,
+    ) -> str:
+        session = await self.create_session(agent=agent)
+        model = _resolve_model(model=self._model, config=self._config)
+        if auto_tools:
+            from opencode._tools import ToolExecutor
+
+            msg = await session.ask(
+                prompt,
+                files=files,
+                model=model,
+                format=format,
+                tool_executor=ToolExecutor(),
+            )
+        else:
+            msg = await session.prompt(
+                prompt,
+                files=files,
+                wait=wait,
+                model=model,
+                format=format,
+                poll_interval=poll_interval,
+                poll_timeout=poll_timeout,
+            )
+        return _extract_text(msg)
+
+    async def ask_stream(
+        self,
+        prompt: str,
+        *,
+        files: Optional[Dict[str, Any]] = None,
+        session: Optional[AsyncSession] = None,
+    ) -> AsyncIterator[str]:
+        import json
+
+        import httpx
+
+        if session is None:
+            session = await self.create_session()
+        # Use V1 synchronous prompt — events arrive via /event
+        body: Dict[str, Any] = {"parts": [{"type": "text", "text": prompt}]}
+        resolved = _resolve_model(model=self._model, config=self._config)
+        if resolved:
+            body["model"] = resolved
+
+        # Subscribe before sending to catch all events
+        response = await self.client.event_subscribe()
+        assert isinstance(response, httpx.Response)
+
+        # Send prompt (V1 sync)
+        await self.client.session_send(session.id, body)
+
+        seen_parts: set[str] = set()
+
+        async for line in response.aiter_lines():
+            if not line.startswith("data: "):
+                continue
+            payload = json.loads(line[6:])
+            event_type = payload.get("type")
+            props = payload.get("properties", {})
+
+            # Skip events for other sessions
+            sid = props.get("sessionID")
+            if sid is not None and sid != session.id:
+                continue
+
+            if event_type == "message.part.delta":
+                if props.get("field") == "text":
+                    part_id = props.get("partID", "")
+                    delta = props.get("delta", "")
+                    if delta:
+                        seen_parts.add(part_id)
+                        yield delta
+
+            elif event_type == "message.part.updated":
+                part = props.get("part", {})
+                part_id = part.get("id", "")
+                if part_id not in seen_parts and part.get("type") == "text":
+                    text = part.get("text", "")
+                    if text:
+                        seen_parts.add(part_id)
+                        yield text
+
+            elif event_type == "session.status":
+                status = props.get("status", {})
+                if isinstance(status, dict) and status.get("type") == "idle":
+                    break
+
+            elif event_type == "session.idle":
+                break
+
+
+async def async_opencode(
+    prompt: str,
+    *,
+    keep: bool = False,
+    auto_tools: bool = False,
+    agent: Optional[str] = None,
+    model: Optional[str] = None,
+    format: Optional[Dict[str, Any]] = None,
+    port: int = 4096,
+    directory: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+) -> str:
+    global _async_opencode_state
+    state = _async_opencode_state
+
+    if not state:
+        cfg = dict(config or {})
+        resolved_agent = agent or ("build" if auto_tools else None)
+        ai = AsyncOpendcode(port=port, directory=directory, config=cfg or None, model=model)
+        ai.start()
+        session = await ai.create_session(agent=resolved_agent)
+        state["ai"] = ai
+        state["session"] = session
+        state["config"] = cfg
+        state["model"] = model
+    else:
+        ai = state["ai"]
+        session = state["session"]
+        if model is not None or config is not None:
+            new_cfg = dict(config or {})
+            if model is not None and model != state.get("model"):
+                warnings.warn("Ignoring new model — using existing session")
+            elif new_cfg != state.get("config", {}):
+                warnings.warn("Ignoring new config — using existing session")
+
+    resolved = _resolve_model(model=state.get("model"), config=state.get("config", {}))
+    if auto_tools:
+        from opencode._tools import ToolExecutor
+
+        msg = await session.ask(prompt, model=resolved, format=format, tool_executor=ToolExecutor())
+    else:
+        msg = await session.prompt(prompt, model=resolved, format=format)
+    result = _extract_text(msg)
+
+    if not keep:
+        await ai.close()
+        state.clear()
+
+    return result

opencode/_async_session.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from opencode._async_client import AsyncOpendcodeClient
+from opencode._models import SessionMessage
+from opencode._tools import ToolExecutor
+
+
+class AsyncSession:
+    def __init__(self, client: AsyncOpendcodeClient, session_id: str):
+        self._client = client
+        self.id = session_id
+        self._auto_confirmed: bool = False
+
+    async def prompt(
+        self,
+        text: str,
+        *,
+        files: Optional[List[Dict[str, Any]]] = None,
+        agents: Optional[List[Dict[str, Any]]] = None,
+        references: Optional[List[Dict[str, Any]]] = None,
+        model: Optional[Dict[str, str]] = None,
+        format: Optional[Dict[str, Any]] = None,
+        wait: bool = True,
+        poll_interval: float = 0.5,
+        poll_timeout: float = 600.0,
+    ) -> SessionMessage:
+        parts: List[Dict[str, Any]] = [{"type": "text", "text": text}]
+        body: Dict[str, Any] = {"parts": parts}
+        if model:
+            body["model"] = model
+        if format:
+            body["format"] = format
+
+        result = await self._client.session_send(self.id, body)
+
+        if isinstance(result, dict):
+            parts_list = result.get("parts", [])
+            info = result.get("info", {})
+            structured = result.get("structured") or info.get("structured")
+            text_parts: List[Dict[str, Any]] = []
+            for p in parts_list:
+                ptype = p.get("type", "")
+                if ptype in ("text", "reasoning", "tool"):
+                    text_parts.append({"type": ptype, "text": p.get("text", "")})
+            msg: Dict[str, Any] = {
+                "id": info.get("id", ""),
+                "type": "assistant",
+                "content": text_parts,
+                "model": info.get("model"),
+                "time": info.get("time", {}),
+            }
+            if structured is not None:
+                msg["structured"] = structured
+            return msg
+
+        return result
+
+    async def ask(
+        self,
+        text: str,
+        *,
+        files: Optional[List[Dict[str, Any]]] = None,
+        model: Optional[Dict[str, str]] = None,
+        format: Optional[Dict[str, Any]] = None,
+        max_tool_rounds: int = 25,
+        tool_executor: Optional[ToolExecutor] = None,
+        quiet: bool = False,
+    ) -> SessionMessage:
+        if tool_executor is None:
+            tool_executor = ToolExecutor()
+        parts: List[Dict[str, Any]] = [{"type": "text", "text": text}]
+        if files:
+            parts.extend(files)
+
+        for _round in range(max_tool_rounds):
+            body: Dict[str, Any] = {"parts": parts}
+            if model:
+                body["model"] = model
+            if format:
+                body["format"] = format
+
+            result = await self._client.session_send(self.id, body)
+            if not isinstance(result, dict):
+                return result
+
+            parts_list = result.get("parts", [])
+            info = result.get("info", {})
+
+            tool_uses = [p for p in parts_list if p.get("type") == "tool-use"]
+            if tool_uses:
+                self._auto_confirmed = True
+                results: List[Dict[str, Any]] = []
+                for tu in tool_uses:
+                    tool_name = tu.get("tool", {}).get("name", "")
+                    tool_input = tu.get("tool", {}).get("input", {})
+                    tool_id = tu.get("toolUseID", "")
+                    if not quiet:
+                        print(f"\033[33m[Tool] {tool_name}\033[0m")
+                    output = tool_executor.execute(tool_name, tool_input)
+                    results.append({
+                        "type": "tool-result",
+                        "toolUseID": tool_id,
+                        "tool": {"name": tool_name},
+                        "output": output,
+                    })
+
+                parts = results
+                continue
+
+            if not self._auto_confirmed:
+                self._auto_confirmed = True
+                parts = [{"type": "text", "text": "Exit plan mode and proceed with execution now. Use tools as needed."}]
+                continue
+
+            text_parts: List[Dict[str, Any]] = []
+            for p in parts_list:
+                ptype = p.get("type", "")
+                if ptype in ("text", "reasoning", "tool"):
+                    text_parts.append({"type": ptype, "text": p.get("text", "")})
+            msg: Dict[str, Any] = {
+                "id": info.get("id", ""),
+                "type": "assistant",
+                "content": text_parts,
+                "model": info.get("model"),
+                "time": info.get("time", {}),
+            }
+            structured = result.get("structured") or info.get("structured")
+            if structured is not None:
+                msg["structured"] = structured
+            return msg
+
+        raise RuntimeError(f"Tool loop exceeded {max_tool_rounds} rounds")
+
+    async def messages(self, **kwargs) -> Any:
+        return await self._client.v2_session_messages(self.id, **kwargs)
+
+    async def context(self, **kwargs) -> List[SessionMessage]:
+        return await self._client.v2_session_context(self.id, **kwargs)
+
+    async def compact(self) -> Any:
+        return await self._client.v2_session_compact(self.id)
+
+    async def abort(self) -> Any:
+        return await self._client.session_abort(self.id)
+
+    async def fork(self, **kwargs) -> Any:
+        return await self._client.session_fork(self.id, **kwargs)
+
+    async def diff(self) -> Any:
+        return await self._client.session_diff(self.id)
+
+    async def todo(self) -> Any:
+        return await self._client.session_todo(self.id)

opencode/_binary.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import os
+import platform
+import re
+import shutil
+import stat
+import sys
+from pathlib import Path
+from typing import Optional
+
+from opencode._errors import BinaryNotFound
+
+
+def _system() -> str:
+    raw = platform.system().lower()
+    if raw == "darwin":
+        return "darwin"
+    if raw == "windows":
+        return "win32"
+    return "linux"
+
+
+def _arch() -> str:
+    raw = platform.machine().lower()
+    if raw in ("amd64", "x86_64"):
+        return "x64"
+    if raw in ("aarch64", "arm64"):
+        return "arm64"
+    return raw
+
+
+def _platform_suffix() -> str:
+    return f"{_system()}-{_arch()}"
+
+
+def _resolve_wrapper(path: str) -> str:
+    """If *path* is a .cmd/.bat wrapper (npm-style), return the real .exe it launches."""
+    if not path.lower().endswith((".cmd", ".bat")):
+        return path
+    try:
+        text = Path(path).read_text(encoding="utf-8", errors="replace")
+        for line in text.splitlines():
+            m = re.search(r'"([^"]+\.exe)"', line)
+            if m:
+                rel = m.group(1)
+                full = rel.replace("%dp0%", os.path.dirname(path)).replace("/", "\\")
+                if os.path.isfile(full):
+                    return os.path.realpath(full)
+    except Exception:
+        pass
+    return path
+
+
+def find_in_path(name: str = "opencode") -> Optional[str]:
+    resolved = shutil.which(name)
+    if resolved:
+        return _resolve_wrapper(resolved)
+    if sys.platform == "win32":
+        for ext in (".exe", ".cmd", ".bat"):
+            resolved = shutil.which(name + ext)
+            if resolved:
+                return _resolve_wrapper(resolved)
+    return None
+
+
+def binary_dir() -> Path:
+    return Path.home() / ".opencode" / "bin"
+
+
+def find_local(name: str = "opencode") -> Optional[str]:
+    candidates = [name]
+    if sys.platform == "win32":
+        candidates = [f"{name}.exe", name]
+    for candidate in candidates:
+        full = binary_dir() / candidate
+        if full.exists():
+            return str(full.resolve())
+    return None
+
+
+def ensure_opencode(name: str = "opencode") -> str:
+    existing = find_in_path(name)
+    if existing:
+        return existing
+    existing = find_local(name)
+    if existing:
+        return existing
+    path = download_opencode(name)
+    return path
+
+
+def download_opencode(
+    name: str = "opencode",
+    version: str = "latest",
+    dest: Optional[Path] = None,
+) -> str:
+    import io
+    import json
+    import tarfile
+    import urllib.request
+    import zipfile
+
+    dest = dest or binary_dir()
+    dest.mkdir(parents=True, exist_ok=True)
+    suffix = _platform_suffix()
+
+    if version == "latest":
+        url = "https://api.github.com/repos/anomalyco/opencode/releases/latest"
+        req = urllib.request.Request(url, headers={"Accept": "application/json", "User-Agent": "opencode-py"})
+        with urllib.request.urlopen(req) as resp:
+            data = json.loads(resp.read().decode())
+            version = data["tag_name"]
+
+    ext = ".zip" if sys.platform == "win32" else ".tar.gz"
+    archive_url = f"https://github.com/anomalyco/opencode/releases/download/{version}/opencode-{suffix}{ext}"
+
+    print(f"Downloading opencode {version} ({suffix})...")
+    req = urllib.request.Request(archive_url, headers={"User-Agent": "opencode-py"})
+    with urllib.request.urlopen(req) as resp:
+        body = resp.read()
+
+    if ext == ".zip":
+        zf = zipfile.ZipFile(io.BytesIO(body))
+        zf.extractall(str(dest))
+    else:
+        tf = tarfile.open(fileobj=io.BytesIO(body), mode="r:gz")
+        tf.extractall(str(dest))
+
+    final = dest / (name + (".exe" if sys.platform == "win32" else ""))
+    if final.exists():
+        final.chmod(final.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+
+    print(f"Downloaded opencode to {final}")
+    return str(final.resolve())