optio-opencode 0.2.4__tar.gz → 0.3.0__tar.gz

{optio_opencode-0.2.4 → optio_opencode-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.2.4
+Version: 0.3.0
 Summary: Run opencode web as an optio task; local subprocess or remote via SSH.
 Author-email: Kristof Csillag <kristof.csillag@deai-labs.com>
 License-Expression: Apache-2.0
@@ -22,12 +22,13 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: optio-core<0.4,>=0.3
 Requires-Dist: optio-host<0.3,>=0.2
-Requires-Dist: optio-agents<0.4,>=0.3
+Requires-Dist: optio-agents<0.5,>=0.4
 Requires-Dist: asyncssh>=2.14
 Requires-Dist: aiohttp>=3.9
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: pytest-xdist>=3.6; extra == "dev"
 
 # optio-opencode
 

{optio_opencode-0.2.4 → optio_opencode-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "optio-opencode"
-version = "0.2.4"
+version = "0.3.0"
 description = "Run opencode web as an optio task; local subprocess or remote via SSH."
 readme = "README.md"
 license = "Apache-2.0"
@@ -30,7 +30,7 @@ dependencies = [
     # 0.1.1 introduces the bind_addr kwarg on Host.establish_tunnel —
     # required for OPTIO_WIDGET_TUNNEL_BIND to work.
     "optio-host>=0.2,<0.3",
-    "optio-agents>=0.3,<0.4",
+    "optio-agents>=0.4,<0.5",
     "asyncssh>=2.14",
     "aiohttp>=3.9",
 ]
@@ -39,6 +39,7 @@ dependencies = [
 dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
+    "pytest-xdist>=3.6",
 ]
 
 [project.urls]
@@ -52,3 +53,6 @@ where = ["src"]
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
+markers = [
+    "serial: spawn-heavy, timing-fragile test that must run in a final non-parallel phase",
+]

{optio_opencode-0.2.4 → optio_opencode-0.3.0}/src/optio_opencode/conversation.py

@@ -57,6 +57,12 @@ class OpencodeConversation:
         # The server resolves instance directories (symlinks etc.) before
         # stamping them onto /global/event frames; compare against realpath too.
         self._directory_real = os.path.realpath(directory)
+        # Active model as "providerID/modelID" (or None → let opencode pick its
+        # own default). The operator UI attaches the model itself, client-side,
+        # per prompt_async; this field is used by the server-side model probe,
+        # which drives a throwaway conversation and must run each turn under a
+        # specific model. Split back into {providerID, modelID} in send().
+        self.current_model_id: str | None = None
         self._pending = False
         self._closed = asyncio.Event()
         self._close_reason: str | None = None
@@ -73,6 +79,12 @@ class OpencodeConversation:
         self._part_texts: dict[str, dict[str, str]] = {}
         self._dispatcher_task: asyncio.Task | None = None
         self._http: aiohttp.ClientSession | None = None
+        # Set once the reader owns an aiohttp session AND the /global/event
+        # stream is connected — i.e. it is safe to send() and expect the answer/
+        # error events back. The model probe waits on this before its first turn
+        # (otherwise it would send() while _http is still None and mark every
+        # model unusable — a startup race).
+        self._ready = asyncio.Event()
 
     # -- wiring ------------------------------------------------------------
 
@@ -111,6 +123,10 @@ class OpencodeConversation:
             self._url("/global/event"), timeout=timeout,
         ) as resp:
             resp.raise_for_status()
+            # The stream is live and _http exists: sends will now reach the
+            # server and their answer/error events will arrive. On a reconnect
+            # this is already set (harmless).
+            self._ready.set()
             # A (re)connect can postdate permission.asked events we never saw.
             await self._sweep_permissions()
             data_lines: list[str] = []
@@ -280,12 +296,21 @@ class OpencodeConversation:
     async def send(self, text: str) -> None:
         if self._closed.is_set():
             raise ConversationClosed(self._close_reason or "conversation closed")
+        if self._http is None:
+            # The reader hasn't created the aiohttp session yet (or was never
+            # started). Fail loudly instead of an opaque AttributeError.
+            raise ConversationClosed("conversation not started")
         self._pending = True
+        body: dict = {"parts": [{"type": "text", "text": text}]}
+        if self.current_model_id:
+            prov, _, mod = self.current_model_id.partition("/")
+            if prov and mod:
+                body["model"] = {"providerID": prov, "modelID": mod}
         try:
             async with self._http.post(
                 self._url(f"/session/{self._session_id}/prompt_async"),
                 params=self._params(),
-                json={"parts": [{"type": "text", "text": text}]},
+                json=body,
             ) as resp:
                 resp.raise_for_status()
         except (aiohttp.ClientError, ConnectionError) as exc:
@@ -327,6 +352,19 @@ class OpencodeConversation:
         ) as resp:
             resp.raise_for_status()
 
+    async def set_active_model(self, model: str) -> None:
+        """Record the model (``"providerID/modelID"``) attached to subsequent
+        sends. Used by the server-side model probe; the operator UI drives its
+        own selection client-side (see set_control)."""
+        self.current_model_id = model
+
+    async def set_control(self, control_id: str, value: "str | bool") -> None:
+        # opencode's session controls (model + reasoning_effort) are both
+        # resolved and applied entirely UI-local — attached per-prompt to
+        # prompt_async (``model`` / ``variant``); there is no server round-trip,
+        # so this satisfies the Conversation protocol as a no-op for either id.
+        return None
+
     async def close(self) -> None:
         self.close_requested.set()
 

{optio_opencode-0.2.4 → optio_opencode-0.3.0}/src/optio_opencode/host_actions.py

@@ -14,7 +14,7 @@ binary cache on the worker
 (``OPENCODE_CACHE_DIR`` / ``${XDG_CACHE_HOME:-$HOME/.cache}/optio-opencode/bin``,
 resolved per host — never the host home bin dir) and is overridable via the
 ``install_dir`` keyword argument on the public entry points; consumers
-expose this as ``OpencodeTaskConfig.opencode_install_dir``.
+expose this as ``OpencodeTaskConfig.install_dir``.
 No isinstance branches.
 """
 
@@ -52,7 +52,7 @@ _OPENCODE_CACHE_SHELL_DEFAULT = (
 async def _resolve_install_dir(host: "Host", install_dir: str | None) -> str:
     """Resolve the opencode binary-cache dir as an absolute path on the worker.
 
-    ``install_dir`` (config.opencode_install_dir) overrides. Else the worker's
+    ``install_dir`` (config.install_dir) overrides. Else the worker's
     OPENCODE_CACHE_DIR / XDG_CACHE_HOME / $HOME decide it — resolved via a shell
     echo so RemoteHost gets the remote cache. Resolved from the worker's REAL env
     (this runs before per-task XDG isolation), so the cache stays shared and
@@ -488,9 +488,16 @@ async def launch_opencode(
     # The browser-suppression env (PATH prepend + BROWSER) comes from extra_env.
     # The HOME/XDG isolation env (from _isolation_env) points opencode's
     # auth/config/data at <workdir>/home so per-task seeding works.
+    # OPENCODE_DISABLE_AUTOUPDATE=1 disables opencode's in-agent auto-updater
+    # (the binary's update fn early-returns on this var). A managed wrapper pins
+    # the binary via optio's own smart-install.sh --check, so a self-download
+    # would fight our version control and can stall/bloat a session mid-run;
+    # disabling it here is safe because the cache stays fresh independently.
+    # Set as a base default; a caller extra_env may still override.
     env = {
         **_isolation_env(host),
         "OPENCODE_DB": f"{host.taskdir}/opencode.db",
+        "OPENCODE_DISABLE_AUTOUPDATE": "1",
         **(extra_env or {}),
     }
 

optio_opencode-0.3.0/src/optio_opencode/model_probe.py

@@ -0,0 +1,141 @@
+"""opencode's conversation-mode model-availability probe (+ per-seed cache).
+
+opencode's ``GET /config/providers`` lists every configured provider/model with
+no per-account entitlement flag. Selecting a model the account cannot use is not
+rejected up front — the turn simply ERRORS (e.g. a ChatGPT-account Codex auth
+rejects ``gpt-5.5-pro`` with ``Bad Request: … not supported when using Codex with
+a ChatGPT account``). So we probe: send each model a trivial question and keep the
+ones that answer without erroring. The result is cached per seed.
+
+The mechanics (cache, disabled-map surfacing, the generic probe loop) live in the
+engine-agnostic ``optio_agents.model_probe`` — shared with optio-cursor. This
+module pins opencode's usable signal (an answer arrived and the turn did NOT
+error), its ``/config/providers`` id enumeration, its cache-collection suffix, and
+its disabled-reason string.
+"""
+from __future__ import annotations
+
+from optio_agents import model_probe as _shared
+
+PROBE_QUESTION = _shared.PROBE_QUESTION
+PROBE_CACHE_SUFFIX = "_opencode_model_probe"
+PROBE_CACHE_TTL = _shared.PROBE_CACHE_TTL
+# Surfaced in the picker (as a tooltip) for a model the probe found unusable —
+# the account/plan can't run it (the provider rejected the probe turn).
+DISABLED_REASON = "Not usable with this account (the provider rejected it)"
+
+probe_cache_key = _shared.probe_cache_key
+run_probe_child = _shared.run_probe_child
+
+
+def _error_from_event(ev: dict):
+    """Map one raw conversation event to an error object, or None. opencode
+    surfaces a failed turn either as a ``session.error`` event or as a completed
+    assistant ``message.updated`` whose ``info`` carries an ``error`` field."""
+    t = ev.get("type")
+    props = ev.get("properties") or {}
+    if t == "session.error":
+        return props.get("error") or {"message": "session error"}
+    if t == "message.updated":
+        info = props.get("info") or {}
+        if info.get("role") == "assistant" and info.get("error"):
+            return info.get("error")
+    return None
+
+
+def _usable(answer, error) -> bool:
+    """A model is usable iff the probe turn produced an answer AND did not end in
+    an error (a timeout leaves answer="" and error=None → unusable)."""
+    return error is None and bool((answer or "").strip())
+
+
+async def probe_models(conversation, model_ids, *, per_model_timeout: float = 30.0, report=None):
+    """Return ``{model_id: usable}`` for opencode's error-signal usable-check."""
+    return await _shared.probe_models(
+        conversation, model_ids,
+        usable_check=_usable,
+        set_model=lambda conv, mid: conv.set_active_model(mid),
+        error_from_event=_error_from_event,
+        per_model_timeout=per_model_timeout,
+        report=report,
+    )
+
+
+def parse_model_ids(providers_json) -> list[str]:
+    """Enumerate ``"providerID/modelID"`` ids from a ``GET /config/providers``
+    response (Python peer of the UI's ``parseProviders``). Shape:
+    ``{providers: [{id, name, models: {<modelId>: {id, providerID, name}}}], …}``."""
+    if not isinstance(providers_json, dict):
+        return []
+    providers = providers_json.get("providers")
+    if not isinstance(providers, list):
+        return []
+    ids: list[str] = []
+    for p in providers:
+        if not isinstance(p, dict):
+            continue
+        pid = p.get("id")
+        models = p.get("models")
+        if not isinstance(models, dict):
+            continue
+        for m in models.values():
+            m = m if isinstance(m, dict) else {}
+            prov = m.get("providerID") or pid
+            mod = m.get("id")
+            if prov and mod:
+                ids.append(f"{prov}/{mod}")
+    return ids
+
+
+def parse_model_variants(providers_json) -> dict[str, list[str]]:
+    """Map ``"providerID/modelID" -> [ordered variant keys]`` for every model
+    that declares a non-empty ``variants`` map in a ``GET /config/providers``
+    response. opencode's per-model ``variants`` are named reasoning-effort
+    presets (e.g. ``{"low": …, "medium": …, "high": …}``); their KEYS are the
+    graded effort levels the widget builds its effort slider from.
+
+    ``parse_model_ids`` (the probe's id enumeration) discards ``variants``; this
+    sibling reads the keys the probe throws away. Models with no ``variants``
+    map are omitted entirely — an unsupported model ⇒ no effort control."""
+    if not isinstance(providers_json, dict):
+        return {}
+    providers = providers_json.get("providers")
+    if not isinstance(providers, list):
+        return {}
+    out: dict[str, list[str]] = {}
+    for p in providers:
+        if not isinstance(p, dict):
+            continue
+        pid = p.get("id")
+        models = p.get("models")
+        if not isinstance(models, dict):
+            continue
+        for m in models.values():
+            m = m if isinstance(m, dict) else {}
+            prov = m.get("providerID") or pid
+            mod = m.get("id")
+            variants = m.get("variants")
+            if not (prov and mod and isinstance(variants, dict) and variants):
+                continue
+            keys = [str(k) for k in variants.keys()]
+            if keys:
+                out[f"{prov}/{mod}"] = keys
+    return out
+
+
+def disabled_map(usable: dict[str, bool]) -> dict[str, str]:
+    """``{model_id: DISABLED_REASON}`` for every unusable id — published in
+    widgetData so OpencodeView greys those models in its client-fetched picker."""
+    return _shared.disabled_map(usable, DISABLED_REASON)
+
+
+async def load_probe_cache(db, prefix: str, seed_id: str, *, now=None):
+    return await _shared.load_probe_cache(
+        db, prefix, seed_id, suffix=PROBE_CACHE_SUFFIX, now=now,
+    )
+
+
+async def save_probe_cache(db, prefix: str, seed_id: str, usable: dict[str, bool], *, now=None):
+    return await _shared.save_probe_cache(
+        db, prefix, seed_id, usable, suffix=PROBE_CACHE_SUFFIX, now=now,
+    )