optio-opencode 0.1.1__tar.gz → 0.1.3__tar.gz

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.1.1
+Version: 0.1.3
 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

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "optio-opencode"
-version = "0.1.1"
+version = "0.1.3"
 description = "Run opencode web as an optio task; local subprocess or remote via SSH."
 readme = "README.md"
 license = "Apache-2.0"

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/src/optio_opencode/host_actions.py

@@ -328,6 +328,7 @@ async def launch_opencode(
     *,
     ready_timeout_s: float = 30.0,
     opencode_executable: str = "opencode",
+    hostname: str = "127.0.0.1",
 ) -> tuple[ProcessHandle, int]:
     """Launch ``opencode web`` on ``host``; wait for the listening URL.
 
@@ -340,6 +341,12 @@ async def launch_opencode(
     directory to PATH so opencode's automatic browser-launch is
     suppressed.
 
+    ``hostname`` is passed to ``opencode web --hostname=`` so callers
+    can bind to a non-loopback interface when consumers reach the server
+    across a network boundary (e.g. LocalHost inside a docker container
+    serving a sibling API-proxy container). Defaults to ``127.0.0.1`` to
+    keep RemoteHost-over-SSH and single-host deployments unchanged.
+
     Returns ``(handle, opencode_port)``. Caller is responsible for
     eventually terminating the handle via ``host.terminate_subprocess``.
     """
@@ -374,7 +381,7 @@ async def launch_opencode(
         f"exec env "
         f"OPENCODE_SERVER_PASSWORD=\"$(cat {shlex.quote(host.workdir + '/' + pw_file)})\" "
         f"BROWSER=true "
-        f"{opencode_executable} web --port=0 --hostname=127.0.0.1"
+        f"{opencode_executable} web --port=0 --hostname={shlex.quote(hostname)}"
     )
 
     # Prepend the noop-browsers bin dir to PATH via env on launch_subprocess.

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/src/optio_opencode/prompt.py

@@ -79,9 +79,18 @@ caveats:**
 
 ### Detecting a resume: `resume.log`
 
-Each session start (fresh or resumed) appends one ISO 8601 timestamp
-to `./resume.log`. The very first line is the original launch
-timestamp; each subsequent line is a resume.
+Each session start (fresh or resumed) appends one line to
+`./resume.log`. Line format:
+
+```
+<ISO 8601 UTC timestamp>[ REFRESHED:<comma-separated filenames>]
+```
+
+The very first line is the original launch timestamp; each subsequent
+line is a resume. The optional `REFRESHED:` suffix signals that the
+harness rewrote the listed files on that resume (e.g.
+`2026-05-28T13:15:42Z REFRESHED:AGENTS.md`) — your in-memory copy of
+those files is stale and must be re-read before continuing.
 
 **At the start of every new incoming user message, read
 `./resume.log` first.** Compare the latest line to the value you
@@ -92,6 +101,10 @@ the situation as a resume:
   outside the workdir are still where you left them.
 - Re-establish anything that's gone (re-launch a server, re-fetch a
   file, etc.) before continuing.
+- **If the latest line carries a `REFRESHED:` suffix, re-read each
+  listed file** (e.g. `cat ./AGENTS.md`) — the harness updated it
+  since your last context snapshot and the version you remember is
+  out of date.
 - Then resume the work you were doing.
 
 If a resume slips past unnoticed, a failing tool call is the

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/src/optio_opencode/session.py

@@ -160,6 +160,7 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
         """
         nonlocal launched_handle, opencode_exec, session_id, preserved_session_id
 
+        refreshed_files: list[str] = []
         if not resuming:
             # Fresh start: the protocol driver has already created the
             # workdir, deliverables/ subdir, and empty optio.log. Ensure
@@ -189,9 +190,14 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
             # self-healing (snapshot lookup returns None → fresh-start
             # fallback) handles the rare case where the flag is true but
             # no snapshot exists.
+        else:
+            # Resume: when on_resume_refresh is wired, recompute AGENTS.md
+            # from the refreshed config and overwrite the workdir copy if
+            # the rendered text differs from the snapshot-restored file.
+            refreshed_files = await _maybe_refresh_on_resume(host, hook_ctx, config)
 
         if config.supports_resume:
-            await _append_resume_log_entry(host)
+            await _append_resume_log_entry(host, refreshed=refreshed_files)
 
         # opencode is already installed by run_opencode_session before
         # this body runs (so resume restore can call opencode_import
@@ -210,14 +216,6 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
             host, opencode_executable=opencode_exec,
         )
         version_suffix = f" {version}" if version else ""
-        ctx.report_progress(None, f"Launching opencode{version_suffix}…")
-        handle, opencode_port = await host_actions.launch_opencode(
-            host, password,
-            ready_timeout_s=READY_TIMEOUT_S,
-            opencode_executable=opencode_exec,
-        )
-        launched_handle = handle
-
         # --- tunnel + widget registration --------------------------------
         # By default the SSH tunnel listens on 127.0.0.1 — only the worker
         # process (this engine) can reach it.  For multi-container deploys
@@ -230,6 +228,22 @@ async def run_opencode_session(ctx: ProcessContext, config: OpencodeTaskConfig)
         # 127.0.0.1 so single-host deploys are unchanged.
         bind_addr = os.environ.get("OPTIO_WIDGET_TUNNEL_BIND", "127.0.0.1")
         upstream_host = os.environ.get("OPTIO_WIDGET_TUNNEL_HOST", "127.0.0.1")
+
+        # LocalHost has no SSH tunnel — establish_tunnel is a no-op — so
+        # opencode itself must bind to ``bind_addr`` for sibling containers
+        # to reach it. RemoteHost keeps opencode bound to the remote's
+        # loopback; the SSH tunnel on the engine side handles exposure.
+        opencode_hostname = bind_addr if isinstance(host, LocalHost) else "127.0.0.1"
+
+        ctx.report_progress(None, f"Launching opencode{version_suffix}…")
+        handle, opencode_port = await host_actions.launch_opencode(
+            host, password,
+            ready_timeout_s=READY_TIMEOUT_S,
+            opencode_executable=opencode_exec,
+            hostname=opencode_hostname,
+        )
+        launched_handle = handle
+
         worker_port = await host.establish_tunnel(opencode_port, bind_addr=bind_addr)
 
         if preserved_session_id is not None:
@@ -461,16 +475,26 @@ async def _rotate_optio_log(host: Host) -> None:
     await host.write_text("optio.log", "")
 
 
-async def _append_resume_log_entry(host) -> None:
-    """Append one ISO 8601 UTC timestamp line to <workdir>/resume.log.
+async def _append_resume_log_entry(
+    host, *, refreshed: list[str] | None = None,
+) -> None:
+    """Append one line to <workdir>/resume.log.
+
+    Line format: ``<ISO 8601 UTC timestamp>[ REFRESHED:<comma-separated names>]``.
+    The optional ``REFRESHED:`` suffix signals that the harness rewrote
+    the listed files on this session start. Agents are instructed (via
+    the resume section of AGENTS.md) to re-read tagged files.
 
     Creates the file if missing (via shell `>>`). Caller is responsible
     for gating this on config.supports_resume.
     """
     ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    line = ts
+    if refreshed:
+        line = f"{ts} REFRESHED:{','.join(refreshed)}"
     target = f"{host.workdir}/resume.log"
     result = await host.run_command(
-        f"echo {shlex.quote(ts)} >> {shlex.quote(target)}"
+        f"echo {shlex.quote(line)} >> {shlex.quote(target)}"
     )
     if result.exit_code != 0:
         raise RuntimeError(
@@ -479,6 +503,46 @@ async def _append_resume_log_entry(host) -> None:
         )
 
 
+async def _maybe_refresh_on_resume(
+    host, hook_ctx, config: OpencodeTaskConfig,
+) -> list[str]:
+    """Run the on_resume_refresh hook (if any) and rewrite AGENTS.md when
+    the rendered content differs from the workdir copy.
+
+    Returns the list of filenames the harness rewrote (currently at most
+    ``["AGENTS.md"]``), suitable for tagging the next ``resume.log`` line.
+    A hook that raises is logged and ignored — the resumed session keeps
+    whatever AGENTS.md the snapshot restored.
+    """
+    if config.on_resume_refresh is None:
+        return []
+    try:
+        new_config = config.on_resume_refresh(config)
+    except Exception:
+        _LOG.exception(
+            "on_resume_refresh raised; keeping existing AGENTS.md from snapshot",
+        )
+        return []
+    new_agents_md = compose_agents_md(
+        new_config.consumer_instructions,
+        workdir_exclude=new_config.workdir_exclude,
+        supports_resume=new_config.supports_resume,
+    )
+    try:
+        existing = await hook_ctx.read_text_from_host("AGENTS.md", silent=True)
+    except FileNotFoundError:
+        existing = None
+    except Exception:
+        _LOG.exception(
+            "failed to read existing AGENTS.md on resume; rewriting unconditionally",
+        )
+        existing = None
+    if existing == new_agents_md:
+        return []
+    await host.write_text("AGENTS.md", new_agents_md)
+    return ["AGENTS.md"]
+
+
 def _pick_local_workdir() -> str:
     return tempfile.mkdtemp(prefix="optio-opencode-")
 

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/src/optio_opencode/types.py

@@ -43,6 +43,14 @@ class OpencodeTaskConfig:
     # raises a config error: asymmetric usage is always a mistake.
     session_blob_encrypt: Callable[[bytes], bytes] | None = None
     session_blob_decrypt: Callable[[bytes], bytes] | None = None
+    # Optional hook fired on resume only (never on fresh start). Receives
+    # the original task config; returns a (possibly mutated/replaced) config.
+    # The harness re-renders AGENTS.md from the returned config and writes
+    # it back to the workdir only when it differs from the file on disk.
+    # When written, the harness tags the new line in resume.log with
+    # `REFRESHED:AGENTS.md` so the agent knows to re-read. None (default)
+    # → no refresh; the resumed session keeps its original AGENTS.md.
+    on_resume_refresh: Callable[["OpencodeTaskConfig"], "OpencodeTaskConfig"] | None = None
 
     def __post_init__(self) -> None:
         e = self.session_blob_encrypt is not None

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/src/optio_opencode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: optio-opencode
-Version: 0.1.1
+Version: 0.1.3
 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

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/tests/test_host_local.py

@@ -64,6 +64,50 @@ async def test_launch_times_out_on_no_url(tmp_path):
     pass
 
 
+async def test_launch_opencode_passes_hostname_into_cmd(local_host, monkeypatch):
+    """Multi-container deploys need opencode bound to a non-loopback
+    interface so a sibling API-proxy container can reach it. The
+    ``hostname`` kwarg must propagate into the ``opencode web
+    --hostname=`` argument."""
+    captured: dict[str, str] = {}
+
+    async def fake_launch_subprocess(self, cmd, *, env=None, cwd=None):
+        captured["cmd"] = cmd
+        raise RuntimeError("stop before waiting on stdout")
+
+    monkeypatch.setattr(LocalHost, "launch_subprocess", fake_launch_subprocess)
+
+    await local_host.setup_workdir()
+    with pytest.raises(RuntimeError, match="stop before"):
+        await host_actions.launch_opencode(
+            local_host, password="pw",
+            ready_timeout_s=1.0,
+            opencode_executable="opencode",
+            hostname="0.0.0.0",
+        )
+    assert "--hostname=0.0.0.0" in captured["cmd"]
+
+
+async def test_launch_opencode_default_hostname_is_loopback(local_host, monkeypatch):
+    """Default keeps single-host / RemoteHost-over-SSH behaviour intact."""
+    captured: dict[str, str] = {}
+
+    async def fake_launch_subprocess(self, cmd, *, env=None, cwd=None):
+        captured["cmd"] = cmd
+        raise RuntimeError("stop")
+
+    monkeypatch.setattr(LocalHost, "launch_subprocess", fake_launch_subprocess)
+
+    await local_host.setup_workdir()
+    with pytest.raises(RuntimeError, match="stop"):
+        await host_actions.launch_opencode(
+            local_host, password="pw",
+            ready_timeout_s=1.0,
+            opencode_executable="opencode",
+        )
+    assert "--hostname=127.0.0.1" in captured["cmd"]
+
+
 async def test_tail_file_yields_appended_lines(local_host):
     await local_host.setup_workdir()
     log_path = os.path.join(local_host.workdir, "optio.log")

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/tests/test_session_hooks.py

@@ -118,7 +118,7 @@ def _patch_host_actions(monkeypatch, host):
     async def _version(_host, *, opencode_executable="opencode"):
         return None
 
-    async def _launch(_host, _password, *, ready_timeout_s=30.0, opencode_executable="opencode"):
+    async def _launch(_host, _password, *, ready_timeout_s=30.0, opencode_executable="opencode", hostname="127.0.0.1"):
         host.timeline.append("launch_opencode")
         raise RuntimeError("test never gets past launch")
 

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/tests/test_session_local.py

@@ -105,7 +105,7 @@ def _supply_scenario(monkeypatch):
     orig_launch = host_actions.launch_opencode
     scenario_holder: dict = {"name": "happy"}
 
-    async def _launch(host, password, *, ready_timeout_s=30.0, opencode_executable="opencode"):
+    async def _launch(host, password, *, ready_timeout_s=30.0, opencode_executable="opencode", hostname="127.0.0.1"):
         del opencode_executable  # we substitute fully
         return await orig_launch(
             host, password,
@@ -114,6 +114,7 @@ def _supply_scenario(monkeypatch):
                 f"{sys.executable} {FAKE_OPENCODE} "
                 f"--scenario {scenario_holder['name']}"
             ),
+            hostname=hostname,
         )
     monkeypatch.setattr(host_actions, "launch_opencode", _launch)
 
@@ -347,6 +348,185 @@ async def test_append_resume_log_entry_appends_on_repeat_call(tmp_workdir):
     assert lines[0] != lines[1]
 
 
+async def test_append_resume_log_entry_with_refreshed_tag(tmp_workdir):
+    """Passing refreshed=[...] adds ` REFRESHED:<files>` suffix to the line."""
+    import os
+    import re
+    from optio_host.host import LocalHost
+    from optio_opencode.session import _append_resume_log_entry
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+
+    await _append_resume_log_entry(host, refreshed=["AGENTS.md"])
+
+    resume_log = os.path.join(host.workdir, "resume.log")
+    with open(resume_log) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert len(lines) == 1
+    assert re.match(
+        r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z REFRESHED:AGENTS\.md$",
+        lines[0],
+    )
+
+
+async def test_append_resume_log_entry_with_multiple_refreshed_files(tmp_workdir):
+    """refreshed=[a, b] → REFRESHED:a,b (comma-separated, no spaces)."""
+    import os
+    import re
+    from optio_host.host import LocalHost
+    from optio_opencode.session import _append_resume_log_entry
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+
+    await _append_resume_log_entry(host, refreshed=["AGENTS.md", "opencode.json"])
+
+    resume_log = os.path.join(host.workdir, "resume.log")
+    with open(resume_log) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert len(lines) == 1
+    assert re.match(
+        r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z REFRESHED:AGENTS\.md,opencode\.json$",
+        lines[0],
+    )
+
+
+async def test_append_resume_log_entry_empty_refreshed_omits_tag(tmp_workdir):
+    """refreshed=[] → bare timestamp, no REFRESHED: suffix (same as None)."""
+    import os
+    import re
+    from optio_host.host import LocalHost
+    from optio_opencode.session import _append_resume_log_entry
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+
+    await _append_resume_log_entry(host, refreshed=[])
+
+    resume_log = os.path.join(host.workdir, "resume.log")
+    with open(resume_log) as f:
+        lines = [line for line in f.read().splitlines() if line]
+    assert len(lines) == 1
+    assert re.match(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$", lines[0])
+
+
+# ---- resume refresh -------------------------------------------------------
+
+
+async def test_maybe_refresh_on_resume_no_hook(tmp_workdir):
+    """on_resume_refresh=None → returns [] and does not write AGENTS.md."""
+    import os
+    from optio_host.host import LocalHost
+    from optio_opencode.session import _maybe_refresh_on_resume
+    from optio_opencode.types import OpencodeTaskConfig
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+    config = OpencodeTaskConfig(consumer_instructions="x")
+
+    refreshed = await _maybe_refresh_on_resume(host, None, config)
+
+    assert refreshed == []
+    assert not os.path.exists(os.path.join(host.workdir, "AGENTS.md"))
+
+
+async def test_maybe_refresh_on_resume_unchanged_content_skips_write(tmp_workdir):
+    """Hook return identical to existing AGENTS.md → no write, [] returned."""
+    import os
+    from optio_host.host import LocalHost
+    from optio_opencode.prompt import compose_agents_md
+    from optio_opencode.session import _maybe_refresh_on_resume
+    from optio_opencode.types import OpencodeTaskConfig
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+    config = OpencodeTaskConfig(
+        consumer_instructions="task X",
+        on_resume_refresh=lambda c: c,
+    )
+    expected = compose_agents_md(
+        config.consumer_instructions,
+        workdir_exclude=config.workdir_exclude,
+        supports_resume=config.supports_resume,
+    )
+    await host.write_text("AGENTS.md", expected)
+    mtime_before = os.path.getmtime(os.path.join(host.workdir, "AGENTS.md"))
+
+    class _FakeHookCtx:
+        async def read_text_from_host(self, path, *, silent=False):
+            full = os.path.join(host.workdir, path)
+            with open(full) as f:
+                return f.read()
+
+    refreshed = await _maybe_refresh_on_resume(host, _FakeHookCtx(), config)
+
+    assert refreshed == []
+    mtime_after = os.path.getmtime(os.path.join(host.workdir, "AGENTS.md"))
+    assert mtime_after == mtime_before  # write was skipped
+
+
+async def test_maybe_refresh_on_resume_changed_content_writes(tmp_workdir):
+    """Hook returns new instructions → AGENTS.md rewritten, ['AGENTS.md']."""
+    import os
+    from dataclasses import replace
+    from optio_host.host import LocalHost
+    from optio_opencode.prompt import compose_agents_md
+    from optio_opencode.session import _maybe_refresh_on_resume
+    from optio_opencode.types import OpencodeTaskConfig
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+    config = OpencodeTaskConfig(
+        consumer_instructions="old task",
+        on_resume_refresh=lambda c: replace(c, consumer_instructions="new task"),
+    )
+    old_agents = compose_agents_md(
+        "old task",
+        workdir_exclude=config.workdir_exclude,
+        supports_resume=config.supports_resume,
+    )
+    await host.write_text("AGENTS.md", old_agents)
+
+    class _FakeHookCtx:
+        async def read_text_from_host(self, path, *, silent=False):
+            full = os.path.join(host.workdir, path)
+            with open(full) as f:
+                return f.read()
+
+    refreshed = await _maybe_refresh_on_resume(host, _FakeHookCtx(), config)
+
+    assert refreshed == ["AGENTS.md"]
+    with open(os.path.join(host.workdir, "AGENTS.md")) as f:
+        content = f.read()
+    assert "new task" in content
+    assert "old task" not in content
+
+
+async def test_maybe_refresh_on_resume_hook_raises_keeps_existing(tmp_workdir):
+    """Hook that raises → returns [] and leaves existing AGENTS.md alone."""
+    import os
+    from optio_host.host import LocalHost
+    from optio_opencode.session import _maybe_refresh_on_resume
+    from optio_opencode.types import OpencodeTaskConfig
+
+    def _boom(c):
+        raise RuntimeError("hook is broken")
+
+    host = LocalHost(taskdir=tmp_workdir)
+    await host.setup_workdir()
+    await host.write_text("AGENTS.md", "existing content")
+    config = OpencodeTaskConfig(
+        consumer_instructions="x", on_resume_refresh=_boom,
+    )
+
+    refreshed = await _maybe_refresh_on_resume(host, None, config)
+
+    assert refreshed == []
+    with open(os.path.join(host.workdir, "AGENTS.md")) as f:
+        assert f.read() == "existing content"
+
+
 async def test_session_local_supports_resume_false_skips_resume_log(
     ctx_and_captures, _supply_scenario, tmp_workdir, monkeypatch,
 ):

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/tests/test_session_resume.py

@@ -53,7 +53,7 @@ def _supply_scenario(monkeypatch):
     orig_launch = host_actions.launch_opencode
     holder = {"name": "happy"}
 
-    async def _launch(host, password, *, ready_timeout_s=30.0, opencode_executable="opencode"):
+    async def _launch(host, password, *, ready_timeout_s=30.0, opencode_executable="opencode", hostname="127.0.0.1"):
         del opencode_executable
         return await orig_launch(
             host, password,
@@ -61,6 +61,7 @@ def _supply_scenario(monkeypatch):
             opencode_executable=(
                 f"{sys.executable} {FAKE_OPENCODE} --scenario {holder['name']}"
             ),
+            hostname=hostname,
         )
     monkeypatch.setattr(host_actions, "launch_opencode", _launch)
 
@@ -183,7 +184,15 @@ async def test_resume_appends_second_line_to_resume_log(mongo_db, task_root):
     lines = [line for line in contents.splitlines() if line]
     assert len(lines) == 2, f"expected 2 lines, got {len(lines)}: {contents!r}"
 
-    iso_re = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
+    # Line format: `<ISO 8601 timestamp>[ REFRESHED:<comma-separated names>]`.
+    # This test exercises the no-refresh path (no on_resume_refresh hook),
+    # so every line is a bare timestamp; the regex still accepts the
+    # extended form to stay valid as the format evolves.
+    line_re = re.compile(
+        r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z(?: REFRESHED:\S+)?$"
+    )
     for line in lines:
-        assert iso_re.match(line), f"non-ISO-8601 line: {line!r}"
-    assert lines[0] <= lines[1], f"timestamps not monotonic: {lines!r}"
+        assert line_re.match(line), f"unrecognized resume.log line: {line!r}"
+    # Timestamps (the leading token of each line) are monotonic.
+    timestamps = [line.split()[0] for line in lines]
+    assert timestamps[0] <= timestamps[1], f"timestamps not monotonic: {timestamps!r}"

{optio_opencode-0.1.1 → optio_opencode-0.1.3}/tests/test_types.py

@@ -95,3 +95,16 @@ def test_opencode_task_config_supports_resume_default_true():
 def test_opencode_task_config_supports_resume_can_be_disabled():
     cfg = OpencodeTaskConfig(consumer_instructions="x", supports_resume=False)
     assert cfg.supports_resume is False
+
+
+def test_opencode_task_config_on_resume_refresh_default_none():
+    cfg = OpencodeTaskConfig(consumer_instructions="x")
+    assert cfg.on_resume_refresh is None
+
+
+def test_opencode_task_config_on_resume_refresh_accepts_callable():
+    def _refresh(c):
+        return c
+
+    cfg = OpencodeTaskConfig(consumer_instructions="x", on_resume_refresh=_refresh)
+    assert cfg.on_resume_refresh is _refresh