opencode-python-sdk 0.1.3__py3-none-any.whl → 0.2.0__py3-none-any.whl

opencode/__init__.py

@@ -14,7 +14,8 @@ Quick start::
 
 from __future__ import annotations
 
-from . import types
+from typing import TYPE_CHECKING, Any
+
 from ._client import AsyncOpencode, Opencode
 
 # <generated:error-imports>
@@ -108,6 +109,9 @@ from ._rpc import (
     rpc_method,
 )
 
+if TYPE_CHECKING:
+    from . import types
+
 # <generated:api-version>
 API_VERSION = "2.1.2"
 """The OpenCode server version this client was generated from."""
@@ -206,3 +210,12 @@ __all__ = [
     "WorktreeError",
     # </generated:error-exports>
 ]
+
+
+def __getattr__(name: str) -> Any:
+    # `opencode.types` builds several hundred models, so it is imported on first use rather than with the package.
+    if name == "types":
+        import importlib
+
+        return importlib.import_module(".types", __name__)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

opencode/_base_client.py

@@ -7,6 +7,7 @@ transient failures, and turns responses into typed values or errors.
 from __future__ import annotations
 
 import base64
+import builtins
 import email.utils
 import functools
 import json
@@ -60,8 +61,18 @@ def _cached_adapter(tp: Any) -> pydantic.TypeAdapter[Any]:
     return pydantic.TypeAdapter(tp)
 
 
+@functools.cache
+def _resolve_type(expr: str) -> Any:
+    # Generated resources name their response types as strings, so `import opencode` does not build every model.
+    from . import types
+
+    return eval(expr, {**vars(types), "builtins": builtins})  # expressions come from the generator
+
+
 def type_adapter(tp: Any) -> pydantic.TypeAdapter[Any]:
-    """Returns a cached ``TypeAdapter`` for a response type."""
+    """Returns a cached ``TypeAdapter`` for a response type, or for a type expression over ``opencode.types``."""
+    if isinstance(tp, str):
+        tp = _resolve_type(tp)
     try:
         return _cached_adapter(tp)
     except TypeError:  # unhashable type expression
@@ -307,6 +318,7 @@ class SyncAPIClient(_BaseClient):
         default_headers: Mapping[str, str] | None,
         default_query: Mapping[str, object] | None,
         http_client: httpx.Client | None,
+        transport: httpx.BaseTransport | None = None,
     ) -> None:
         super().__init__(
             base_url=base_url,
@@ -319,7 +331,11 @@ class SyncAPIClient(_BaseClient):
             default_query=default_query,
         )
         self._owns_http = http_client is None
-        self._http = http_client or httpx.Client(limits=constants.DEFAULT_CONNECTION_LIMITS, follow_redirects=True)
+        if http_client is not None and transport is not None:
+            raise ValueError("Pass either http_client or transport, not both")
+        self._http = http_client or httpx.Client(
+            limits=constants.DEFAULT_CONNECTION_LIMITS, follow_redirects=True, transport=transport
+        )
 
     def close(self) -> None:
         """Closes the connection pool, unless it was passed in by the caller."""
@@ -421,6 +437,7 @@ class AsyncAPIClient(_BaseClient):
         default_headers: Mapping[str, str] | None,
         default_query: Mapping[str, object] | None,
         http_client: httpx.AsyncClient | None,
+        transport: httpx.AsyncBaseTransport | None = None,
     ) -> None:
         super().__init__(
             base_url=base_url,
@@ -433,7 +450,11 @@ class AsyncAPIClient(_BaseClient):
             default_query=default_query,
         )
         self._owns_http = http_client is None
-        self._http = http_client or httpx.AsyncClient(limits=constants.DEFAULT_CONNECTION_LIMITS, follow_redirects=True)
+        if http_client is not None and transport is not None:
+            raise ValueError("Pass either http_client or transport, not both")
+        self._http = http_client or httpx.AsyncClient(
+            limits=constants.DEFAULT_CONNECTION_LIMITS, follow_redirects=True, transport=transport
+        )
 
     async def close(self) -> None:
         """Closes the connection pool, unless it was passed in by the caller."""

opencode/_client.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from functools import cached_property
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from typing_extensions import Self
 
@@ -14,12 +14,17 @@ from .resources import AsyncResources, SyncResources
 
 if TYPE_CHECKING:
     import os
-    from collections.abc import Mapping
+    from collections.abc import Iterable, Mapping
 
     import httpx
 
+    from .testing import FakeServer
+
 __all__ = ["AsyncOpencode", "Opencode"]
 
+FAKE_BASE_URL = "http://opencode.fake"
+"""Base URL of clients made by ``Opencode.fake()``."""
+
 
 class Opencode(SyncAPIClient, SyncResources):
     """Synchronous client for an OpenCode server.
@@ -38,6 +43,8 @@ class Opencode(SyncAPIClient, SyncResources):
         default_query: Query parameters sent with every request.
         http_client: A preconfigured ``httpx.Client`` (proxies, custom transports, event hooks). The caller keeps
             ownership and must close it.
+        transport: An ``httpx`` transport for the client's own connection pool, such as
+            :class:`opencode.testing.FakeServer`. Cannot be combined with ``http_client``.
 
     Example::
 
@@ -60,6 +67,7 @@ class Opencode(SyncAPIClient, SyncResources):
         default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         http_client: httpx.Client | None = None,
+        transport: httpx.BaseTransport | None = None,
     ) -> None:
         super().__init__(
             base_url=base_url,
@@ -71,6 +79,7 @@ class Opencode(SyncAPIClient, SyncResources):
             default_headers=default_headers,
             default_query=default_query,
             http_client=http_client,
+            transport=transport,
         )
 
     @cached_property
@@ -83,6 +92,33 @@ class Opencode(SyncAPIClient, SyncResources):
         """Plugin RPC calls: ``client.rpc.call(...)``, or ``client.rpc(Definition)`` for typed access."""
         return TypedRpcResource(self)
 
+    @classmethod
+    def fake(cls, server: FakeServer | None = None, **kwargs: Any) -> Self:
+        """Returns a client wired to an in-process :class:`opencode.testing.FakeServer`, for tests.
+
+        Pass your own ``server`` to configure replies and inspect requests; other arguments go to the constructor.
+        """
+        from .testing import FakeServer
+
+        kwargs.setdefault("password", "")
+        return cls(FAKE_BASE_URL, transport=server if server is not None else FakeServer(), **kwargs)
+
+    def wait_until_ready(
+        self, *, agents: Iterable[str] = (), mcp_servers: Iterable[str] = (), timeout: float = 60
+    ) -> None:
+        """Blocks until the server answers, the named ``agents`` are listed and the named ``mcp_servers`` are
+        connected.
+
+        Agents load asynchronously after the server starts, so call this before creating sessions on a freshly
+        booted server. Connection errors and 503s while the server boots count as not ready yet.
+
+        Raises:
+          TimeoutError: Something was still missing after ``timeout`` seconds. The message names it.
+        """
+        from .lib._ready import wait_until_ready
+
+        wait_until_ready(self, agents=agents, mcp_servers=mcp_servers, timeout=timeout)
+
     def with_options(
         self,
         *,
@@ -138,6 +174,7 @@ class AsyncOpencode(AsyncAPIClient, AsyncResources):
         default_headers: Mapping[str, str] | None = None,
         default_query: Mapping[str, object] | None = None,
         http_client: httpx.AsyncClient | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
     ) -> None:
         super().__init__(
             base_url=base_url,
@@ -149,6 +186,7 @@ class AsyncOpencode(AsyncAPIClient, AsyncResources):
             default_headers=default_headers,
             default_query=default_query,
             http_client=http_client,
+            transport=transport,
         )
 
     @cached_property
@@ -161,6 +199,33 @@ class AsyncOpencode(AsyncAPIClient, AsyncResources):
         """Plugin RPC calls: ``client.rpc.call(...)``, or ``client.rpc(Definition)`` for typed access."""
         return AsyncTypedRpcResource(self)
 
+    @classmethod
+    def fake(cls, server: FakeServer | None = None, **kwargs: Any) -> Self:
+        """Returns a client wired to an in-process :class:`opencode.testing.FakeServer`, for tests.
+
+        Pass your own ``server`` to configure replies and inspect requests; other arguments go to the constructor.
+        """
+        from .testing import FakeServer
+
+        kwargs.setdefault("password", "")
+        return cls(FAKE_BASE_URL, transport=server if server is not None else FakeServer(), **kwargs)
+
+    async def wait_until_ready(
+        self, *, agents: Iterable[str] = (), mcp_servers: Iterable[str] = (), timeout: float = 60
+    ) -> None:
+        """Blocks until the server answers, the named ``agents`` are listed and the named ``mcp_servers`` are
+        connected.
+
+        Agents load asynchronously after the server starts, so call this before creating sessions on a freshly
+        booted server. Connection errors and 503s while the server boots count as not ready yet.
+
+        Raises:
+          TimeoutError: Something was still missing after ``timeout`` seconds. The message names it.
+        """
+        from .lib._ready import async_wait_until_ready
+
+        await async_wait_until_ready(self, agents=agents, mcp_servers=mcp_servers, timeout=timeout)
+
     def with_options(
         self,
         *,

opencode/_events.py

@@ -31,7 +31,6 @@ import anyio
 from typing_extensions import Self
 
 from ._exceptions import APIConnectionError, APIStatusError, OpencodeError
-from .types import ServerConnectedEvent
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
@@ -39,7 +38,7 @@ if TYPE_CHECKING:
 
     from ._client import AsyncOpencode, Opencode
     from ._streaming import AsyncStream, Stream
-    from .types import Event
+    from .types import Event, ServerConnectedEvent
 
 __all__ = [
     "SUBSCRIBER_CAPACITY",
@@ -302,6 +301,8 @@ class EventHub:
 
     def _read(self, connection: _SyncConnection) -> None:
         """Reads one connection until it ends, setting ``connection.delivered`` once an event arrives."""
+        from .types import ServerConnectedEvent
+
         stream = self._client.event.subscribe()
         with self._lock:
             connection.stream = stream
@@ -605,6 +606,8 @@ class AsyncEventHub:
 
     async def _read(self, connection: _AsyncConnection) -> None:
         """Reads one connection until it ends, setting ``connection.delivered`` once an event arrives."""
+        from .types import ServerConnectedEvent
+
         stream: AsyncStream[Event] = await self._client.event.subscribe()
         try:
             stream.on_activity = connection.activity

opencode/_rpc.py

@@ -44,7 +44,6 @@ from ._errors import RpcError, RpcInternalError
 from ._exceptions import OpencodeError, validation_summary
 from ._types import NOT_GIVEN, NotGiven
 from .resources.rpc import AsyncRpcResource, RpcResource
-from .types import RpcEvent
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -53,7 +52,7 @@ if TYPE_CHECKING:
     from ._client import AsyncOpencode, Opencode
     from ._events import AsyncSubscription, Subscription
     from ._types import Headers, Timeout
-    from .types import Location
+    from .types import Location, RpcEvent
 
 __all__ = [
     "AsyncRpcClient",
@@ -327,11 +326,15 @@ class RpcClient(Generic[_D]):
 
     def events(self) -> Subscription[RpcEvent]:
         """Subscribes to every event of this RPC, as raw events, on the client's shared event stream."""
+        from .types import RpcEvent
+
         prefix = f"rpc.{self.definition.id}."
         return self._client.events.of_type(RpcEvent).where(lambda event: event.type.startswith(prefix))
 
     def subscribe(self, event: RpcEventDefinition[_T]) -> RpcEvents[_T]:
         """Subscribes to one event of this RPC, with validated data, on the client's shared event stream."""
+        from .types import RpcEvent
+
         _check_event(self.definition, event)
         wire = self.definition.event_type(event)
         return RpcEvents(self._client.events.of_type(RpcEvent).where(lambda raw: raw.type == wire), event)
@@ -396,11 +399,15 @@ class AsyncRpcClient(Generic[_D]):
 
     def events(self) -> AsyncSubscription[RpcEvent]:
         """Subscribes to every event of this RPC, as raw events, on the client's shared event stream."""
+        from .types import RpcEvent
+
         prefix = f"rpc.{self.definition.id}."
         return self._client.events.of_type(RpcEvent).where(lambda event: event.type.startswith(prefix))
 
     def subscribe(self, event: RpcEventDefinition[_T]) -> AsyncRpcEvents[_T]:
         """Subscribes to one event of this RPC, with validated data, on the client's shared event stream."""
+        from .types import RpcEvent
+
         _check_event(self.definition, event)
         wire = self.definition.event_type(event)
         return AsyncRpcEvents(self._client.events.of_type(RpcEvent).where(lambda raw: raw.type == wire), event)

opencode/lib/__init__.py

@@ -0,0 +1,5 @@
+"""Hand-written helpers layered over the generated client."""
+
+from ._session import RunResult
+
+__all__ = ["RunResult"]

opencode/lib/_ready.py

@@ -0,0 +1,91 @@
+"""``client.wait_until_ready``: poll until agents and MCP servers have loaded.
+
+OpenCode loads agents and connects MCP servers in the background after it starts listening, so a freshly booted
+server can answer requests before the agent a caller needs exists.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+import anyio
+
+from .._exceptions import APIConnectionError, ServiceUnavailableError
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from .._client import AsyncOpencode, Opencode
+    from ..types import AgentListResponse, McpListResponse
+
+__all__ = ["POLL_INTERVAL", "async_wait_until_ready", "wait_until_ready"]
+
+POLL_INTERVAL = 0.25
+"""Seconds between polls."""
+
+_TRANSIENT = (APIConnectionError, ServiceUnavailableError)
+
+
+def _missing(
+    agents: frozenset[str],
+    mcp_servers: frozenset[str],
+    agent_list: AgentListResponse | None,
+    mcp_list: McpListResponse | None,
+) -> list[str]:
+    missing: list[str] = []
+    if agents:
+        present = {agent.id for agent in agent_list.data} if agent_list is not None else set[str]()
+        missing += [f"agent {name!r}" for name in sorted(agents - present)]
+    if mcp_servers:
+        connected = (
+            {server.name for server in mcp_list.data if server.status.status == "connected"}
+            if mcp_list is not None
+            else set[str]()
+        )
+        missing += [f"MCP server {name!r}" for name in sorted(mcp_servers - connected)]
+    return missing
+
+
+def wait_until_ready(
+    client: Opencode, *, agents: Iterable[str] = (), mcp_servers: Iterable[str] = (), timeout: float = 60
+) -> None:
+    wanted_agents, wanted_mcp = frozenset(agents), frozenset(mcp_servers)
+    deadline = time.monotonic() + timeout
+    while True:
+        agent_list = mcp_list = None
+        missing = ["server"]
+        try:
+            client.server.info()
+            agent_list = client.agent.list() if wanted_agents else None
+            mcp_list = client.mcp.list() if wanted_mcp else None
+            missing = _missing(wanted_agents, wanted_mcp, agent_list, mcp_list)
+        except _TRANSIENT:
+            pass
+        if not missing:
+            return
+        if time.monotonic() >= deadline:
+            raise TimeoutError(f"OpenCode not ready after {timeout}s; still waiting for {', '.join(missing)}")
+        time.sleep(POLL_INTERVAL)
+
+
+async def async_wait_until_ready(
+    client: AsyncOpencode, *, agents: Iterable[str] = (), mcp_servers: Iterable[str] = (), timeout: float = 60
+) -> None:
+    wanted_agents, wanted_mcp = frozenset(agents), frozenset(mcp_servers)
+    deadline = time.monotonic() + timeout
+    while True:
+        agent_list = mcp_list = None
+        missing = ["server"]
+        try:
+            await client.server.info()
+            agent_list = await client.agent.list() if wanted_agents else None
+            mcp_list = await client.mcp.list() if wanted_mcp else None
+            missing = _missing(wanted_agents, wanted_mcp, agent_list, mcp_list)
+        except _TRANSIENT:
+            pass
+        if not missing:
+            return
+        if time.monotonic() >= deadline:
+            raise TimeoutError(f"OpenCode not ready after {timeout}s; still waiting for {', '.join(missing)}")
+        await anyio.sleep(POLL_INTERVAL)

opencode/lib/_session.py

@@ -0,0 +1,231 @@
+"""``client.session.run``: create or reuse a session, prompt it, wait until idle, and collect the result.
+
+The generated ``SessionResource`` / ``AsyncSessionResource`` inherit from the classes here (see
+``codegen/render.py``, ``HELPER_BASES``), so these methods sit next to the generated ones.
+"""
+
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, cast
+
+import anyio
+
+from .._resource import AsyncAPIResource, SyncAPIResource
+from .._types import NOT_GIVEN, NotGiven, Timeout
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from ..resources.session import AsyncSessionResource, SessionResource
+    from ..types import (
+        AgentID,
+        ModelRef,
+        PromptInputFileAttachment,
+        SessionID,
+        SessionInfo,
+        SessionMessageAssistant,
+        SessionMessageInfo,
+        SessionStructuredError,
+        TokenUsageInfo,
+    )
+
+__all__ = ["AsyncSessionHelpers", "RunResult", "SessionHelpers"]
+
+
+@dataclass
+class RunResult:
+    """What :meth:`SessionHelpers.run` returns."""
+
+    session: SessionInfo
+    """The session as it was after the run. ``session.cost`` and ``session.tokens`` cover the whole session."""
+    messages: list[SessionMessageInfo] = field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
+    """Messages this run added, oldest first, starting with the prompt."""
+
+    @property
+    def assistant_messages(self) -> list[SessionMessageAssistant]:
+        """The assistant messages of this run, oldest first."""
+        from ..types import SessionMessageAssistant
+
+        return [message for message in self.messages if isinstance(message, SessionMessageAssistant)]
+
+    @property
+    def text(self) -> str:
+        """Text of the last assistant message, or ``""`` when the agent produced none."""
+        from ..types import SessionMessageAssistantText
+
+        for message in reversed(self.assistant_messages):
+            parts = [item.text for item in message.content if isinstance(item, SessionMessageAssistantText)]
+            if parts:
+                return "".join(parts)
+        return ""
+
+    @property
+    def outcome(self) -> str | None:
+        """``succeeded``, ``failed`` or ``interrupted``, from the run's idle marker or the session."""
+        from ..types import SessionMessageIdle
+
+        for message in reversed(self.messages):
+            if isinstance(message, SessionMessageIdle):
+                return message.outcome
+        return self.session.outcome
+
+    @property
+    def error(self) -> SessionStructuredError | None:
+        """Why the run failed, from its idle marker or last assistant message, or ``None``."""
+        from ..types import SessionMessageAssistant, SessionMessageIdle
+
+        for message in reversed(self.messages):
+            if isinstance(message, (SessionMessageIdle, SessionMessageAssistant)) and message.error is not None:
+                return message.error
+        return None
+
+    @property
+    def cost(self) -> float:
+        """Cost of this run in USD, summed over its assistant messages."""
+        return sum(message.cost or 0.0 for message in self.assistant_messages)
+
+    @property
+    def tokens(self) -> TokenUsageInfo:
+        """Token usage of this run, summed over its assistant messages."""
+        from ..types import TokenUsageInfo, TokenUsageInfoCache
+
+        total = TokenUsageInfo(input=0, output=0, reasoning=0, cache=TokenUsageInfoCache(read=0, write=0))
+        for message in self.assistant_messages:
+            usage = message.tokens
+            if usage is None:
+                continue
+            total.input += usage.input
+            total.output += usage.output
+            total.reasoning += usage.reasoning
+            total.cache.read += usage.cache.read
+            total.cache.write += usage.cache.write
+        return total
+
+
+def _new_messages(newest_first: list[SessionMessageInfo], marker: str | None) -> list[SessionMessageInfo]:
+    from ..types import SessionMessageUser
+
+    collected: list[SessionMessageInfo] = []
+    for message in newest_first:
+        if marker is not None and message.id == marker:
+            break
+        collected.append(message)
+    collected.reverse()
+    # Drop anything that was already queued before our prompt.
+    for index, message in enumerate(collected):
+        if isinstance(message, SessionMessageUser):
+            return collected[index:]
+    return collected
+
+
+class SessionHelpers(SyncAPIResource):
+    """Hand-written helpers on ``client.session``."""
+
+    def run(
+        self,
+        text: str,
+        *,
+        agent: AgentID | None = None,
+        model: ModelRef | None = None,
+        files: Sequence[PromptInputFileAttachment] | NotGiven = NOT_GIVEN,
+        session_id: SessionID | None = None,
+        timeout: Timeout = None,
+    ) -> RunResult:
+        """Runs one prompt to completion and returns what the agent produced.
+
+        Creates a session with ``agent`` and ``model`` (or reuses ``session_id``, switching its agent and model when
+        given), sends ``text``, blocks until the session is idle, and reads back the new messages and the session's
+        usage.
+
+        If the wait is interrupted (``KeyboardInterrupt``, a timeout, or any other error), the session is
+        interrupted on the server before the error propagates, so no agent keeps running unattended.
+
+        Args:
+          text: The prompt.
+          agent: Agent for a new session, or to switch an existing one to.
+          model: Model for a new session, or to switch an existing one to. Set it with ``agent`` so the session
+            does not start on another model.
+          files: File attachments; images can be ``data:`` URLs.
+          session_id: Continue this session instead of creating one.
+          timeout: Seconds to wait for the session to become idle. ``None`` waits forever.
+
+        Example::
+
+            result = client.session.run("Summarize README.md", agent="build")
+            print(result.text, result.cost)
+        """
+        resource = cast("SessionResource", self)
+        if session_id is None:
+            session = resource.create(agent=agent or NOT_GIVEN, model=model or NOT_GIVEN)
+            session_id = session.id
+            marker = None
+        else:
+            if agent is not None:
+                resource.switch_agent(session_id, agent=agent)
+            if model is not None:
+                resource.switch_model(session_id, model=model)
+            latest = self._client.message.list(session_id, order="desc", limit=1).data
+            marker = latest[0].id if latest else None
+
+        resource.prompt(session_id, text=text, files=files)
+        try:
+            resource.wait(session_id, timeout=timeout)
+        except BaseException:
+            with contextlib.suppress(Exception):
+                resource.interrupt(session_id)
+            raise
+
+        newest_first: list[SessionMessageInfo] = []
+        for message in self._client.message.list(session_id, order="desc"):
+            if marker is not None and message.id == marker:
+                break
+            newest_first.append(message)
+        return RunResult(session=resource.get(session_id), messages=_new_messages(newest_first, marker))
+
+
+class AsyncSessionHelpers(AsyncAPIResource):
+    """Hand-written helpers on ``client.session`` of :class:`opencode.AsyncOpencode`."""
+
+    async def run(
+        self,
+        text: str,
+        *,
+        agent: AgentID | None = None,
+        model: ModelRef | None = None,
+        files: Sequence[PromptInputFileAttachment] | NotGiven = NOT_GIVEN,
+        session_id: SessionID | None = None,
+        timeout: Timeout = None,
+    ) -> RunResult:
+        """Runs one prompt to completion. See :meth:`SessionHelpers.run`.
+
+        Cancelling the task interrupts the session on the server before the cancellation propagates.
+        """
+        resource = cast("AsyncSessionResource", self)
+        if session_id is None:
+            session = await resource.create(agent=agent or NOT_GIVEN, model=model or NOT_GIVEN)
+            session_id = session.id
+            marker = None
+        else:
+            if agent is not None:
+                await resource.switch_agent(session_id, agent=agent)
+            if model is not None:
+                await resource.switch_model(session_id, model=model)
+            latest = (await self._client.message.list(session_id, order="desc", limit=1)).data
+            marker = latest[0].id if latest else None
+
+        await resource.prompt(session_id, text=text, files=files)
+        try:
+            await resource.wait(session_id, timeout=timeout)
+        except BaseException:
+            with anyio.CancelScope(shield=True), contextlib.suppress(Exception):
+                await resource.interrupt(session_id)
+            raise
+
+        newest_first: list[SessionMessageInfo] = []
+        async for message in self._client.message.list(session_id, order="desc"):
+            if marker is not None and message.id == marker:
+                break
+            newest_first.append(message)
+        return RunResult(session=await resource.get(session_id), messages=_new_messages(newest_first, marker))