opencode-py 0.1.0__py3-none-any.whl

opencode/_opencode.py

@@ -0,0 +1,290 @@
+from __future__ import annotations
+
+import json
+import warnings
+from typing import Any, Dict, Iterator, List, Optional
+
+from opencode._client import OpencodeClient
+from opencode._models import SessionMessage
+from opencode._server import OpencodeServer, create_opencode_server
+from opencode._session import Session
+
+_opencode_state: Dict[str, Any] = {}
+
+
+def _resolve_model(
+    model: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+) -> Optional[Dict[str, str]]:
+    model_str = model
+    if not model_str and config:
+        model_str = config.get("model")
+    if not model_str:
+        return None
+    if "/" in model_str:
+        provider, model_id = model_str.split("/", 1)
+        return {"providerID": provider, "modelID": model_id}
+    return {"providerID": "opencode", "modelID": model_str}
+
+
+class Opencode:
+    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[OpencodeClient] = None
+
+    # ------------------------------------------------------------------
+    # Context manager
+    # ------------------------------------------------------------------
+
+    def __enter__(self) -> Opencode:
+        self.start()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        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 = OpencodeClient(
+            base_url=server.url,
+            directory=self._directory,
+            workspace=self._workspace,
+            timeout=self._client_timeout,
+        )
+        self._server = server
+        self._client = client
+
+    def close(self) -> None:
+        if self._client:
+            self._client.close()
+            self._client = None
+        if self._server:
+            self._server.close()
+            self._server = None
+
+    @property
+    def client(self) -> OpencodeClient:
+        self.start()
+        assert self._client is not None
+        return self._client
+
+    @property
+    def server(self) -> OpencodeServer:
+        self.start()
+        assert self._server is not None
+        return self._server
+
+    # ------------------------------------------------------------------
+    # High-level API
+    # ------------------------------------------------------------------
+
+    def create_session(self, agent: Optional[str] = None, **kwargs) -> Session:
+        if agent:
+            kwargs["agent"] = agent
+        raw = self.client.session_create(**kwargs)
+        sid = raw["id"]
+        return Session(self.client, sid)
+
+    def _resolve_model(self) -> Optional[Dict[str, str]]:
+        return _resolve_model(model=self._model, config=self._config)
+
+    def ask(
+        self,
+        prompt: str,
+        *,
+        files: Optional[List[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 = self.create_session(agent=agent)
+        if auto_tools:
+            from opencode._tools import ToolExecutor
+
+            msg = session.ask(
+                prompt,
+                files=files,
+                model=self._resolve_model(),
+                format=format,
+                tool_executor=ToolExecutor(),
+            )
+        else:
+            msg = session.prompt(
+                prompt,
+                files=files,
+                wait=wait,
+                model=self._resolve_model(),
+                format=format,
+                poll_interval=poll_interval,
+                poll_timeout=poll_timeout,
+            )
+        return _extract_text(msg)
+
+    def ask_stream(
+        self,
+        prompt: str,
+        *,
+        files: Optional[List[Dict[str, Any]]] = None,
+        session: Optional[Session] = None,
+    ) -> Iterator[str]:
+        import json
+
+        import httpx
+
+        if session is None:
+            session = self.create_session()
+        # Use V1 synchronous prompt — the response events arrive via /event
+        body: Dict[str, Any] = {"parts": [{"type": "text", "text": prompt}]}
+        resolved = self._resolve_model()
+        if resolved:
+            body["model"] = resolved
+
+        # Subscribe before sending to catch all events
+        response = self.client.event_subscribe()
+        assert isinstance(response, httpx.Response)
+
+        # Send prompt (V1 sync)
+        self.client.session_send(session.id, body)
+
+        seen_parts: set[str] = set()
+
+        for line in response.iter_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
+
+
+def _extract_text(msg: SessionMessage) -> str:
+    if isinstance(msg, dict) and msg.get("type") == "assistant":
+        structured = msg.get("structured")
+        if structured is not None:
+            return json.dumps(structured, ensure_ascii=False, default=str)
+        parts = msg.get("content", [])
+        texts: List[str] = []
+        for part in parts:
+            if isinstance(part, dict) and part.get("type") == "text":
+                texts.append(part.get("text", ""))
+        return "\n".join(texts)
+    if isinstance(msg, dict) and msg.get("type") == "user":
+        return msg.get("text", "")
+    return str(msg)
+
+
+def 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 _opencode_state
+    state = _opencode_state
+
+    if not state:
+        cfg = dict(config or {})
+        resolved_agent = agent or ("build" if auto_tools else None)
+        ai = Opencode(port=port, directory=directory, config=cfg or None, model=model)
+        ai.start()
+        session = 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 = session.ask(prompt, model=resolved, format=format, tool_executor=ToolExecutor())
+    else:
+        msg = session.prompt(prompt, model=resolved, format=format)
+    result = _extract_text(msg)
+
+    if not keep:
+        ai.close()
+        state.clear()
+
+    return result

opencode/_process.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import signal
+import subprocess
+import sys
+
+
+def stop(proc: subprocess.Popen) -> None:
+    if proc.poll() is not None:
+        return
+    if sys.platform == "win32" and proc.pid:
+        try:
+            subprocess.run(
+                ["taskkill", "/pid", str(proc.pid), "/T", "/F"],
+                capture_output=True,
+                timeout=5,
+            )
+            return
+        except Exception:
+            pass
+    try:
+        proc.send_signal(signal.SIGTERM)
+    except Exception:
+        pass

opencode/_server.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from typing import Any, Dict, Optional
+
+from opencode._binary import ensure_opencode
+from opencode._errors import ServerStartupTimeout
+from opencode._process import stop
+
+
+class OpencodeServer:
+    def __init__(self, proc: subprocess.Popen, url: str, binary: str):
+        self._proc = proc
+        self.url = url
+        self.binary = binary
+
+    def close(self) -> None:
+        stop(self._proc)
+
+    @property
+    def pid(self) -> Optional[int]:
+        return self._proc.pid
+
+    @property
+    def running(self) -> bool:
+        return self._proc.poll() is None
+
+
+def create_opencode_server(
+    *,
+    hostname: str = "127.0.0.1",
+    port: int = 4096,
+    timeout: float = 30.0,
+    config: Optional[Dict[str, Any]] = None,
+    opencode_binary: Optional[str] = None,
+) -> OpencodeServer:
+    binary = opencode_binary or ensure_opencode()
+
+    args = [binary, "serve", f"--hostname={hostname}", f"--port={port}"]
+    env = os.environ.copy()
+    if config:
+        env["OPENCODE_CONFIG_CONTENT"] = json.dumps(config)
+
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=env,
+    )
+
+    start_time = time.monotonic()
+    output = ""
+    url: Optional[str] = None
+
+    while time.monotonic() - start_time < timeout:
+        line = proc.stdout.readline() if proc.stdout else b""
+        if not line:
+            if proc.poll() is not None:
+                stderr_output = ""
+                if proc.stderr:
+                    stderr_output = proc.stderr.read().decode("utf-8", errors="replace")
+                raise RuntimeError(
+                    f"opencode exited with code {proc.returncode}"
+                    f"\nstdout: {output}"
+                    f"\nstderr: {stderr_output}"
+                )
+            time.sleep(0.05)
+            continue
+
+        decoded = line.decode("utf-8", errors="replace").strip()
+        output += decoded + "\n"
+
+        m = re.search(r"on\s+(https?://[^\s]+)", decoded)
+        if m:
+            url = m.group(1)
+            break
+
+    if not url:
+        stop(proc)
+        stderr_output = ""
+        if proc.stderr:
+            try:
+                stderr_output = proc.stderr.read().decode("utf-8", errors="replace")
+            except Exception:
+                pass
+        raise ServerStartupTimeout(
+            f"Timeout waiting for opencode server after {timeout}s"
+            f"\nstdout: {output}"
+            f"\nstderr: {stderr_output}",
+        )
+
+    return OpencodeServer(proc, url, binary)

opencode/_session.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, List, Optional
+
+from opencode._client import OpencodeClient
+from opencode._models import SessionMessage
+from opencode._tools import ToolExecutor
+
+
+class Session:
+    def __init__(self, client: OpencodeClient, session_id: str):
+        self._client = client
+        self.id = session_id
+        self._auto_confirmed: bool = False
+
+    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
+
+        # Use V1 sync prompt (POST /session/:id/message)
+        result = 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")
+            # Convert parts to V2-like SessionMessage format
+            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
+
+    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 = 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
+
+            # No tool-use parts — model may be planning or asking.
+            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
+
+            # Final response (no tool calls, already confirmed)
+            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")
+
+    def messages(self, **kwargs) -> Any:
+        return self._client.v2_session_messages(self.id, **kwargs)
+
+    def context(self, **kwargs) -> List[SessionMessage]:
+        return self._client.v2_session_context(self.id, **kwargs)
+
+    def compact(self) -> Any:
+        return self._client.v2_session_compact(self.id)
+
+    def abort(self) -> Any:
+        return self._client.session_abort(self.id)
+
+    def fork(self, **kwargs) -> Any:
+        return self._client.session_fork(self.id, **kwargs)
+
+    def diff(self) -> Any:
+        return self._client.session_diff(self.id)
+
+    def todo(self) -> Any:
+        return self._client.session_todo(self.id)