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

opencode/testing.py

@@ -0,0 +1,508 @@
+"""An in-process fake OpenCode server for your own tests.
+
+:class:`FakeServer` is an ``httpx`` transport that answers like an OpenCode server, keeping sessions, messages and
+events in memory. Plug it into a client and test code that uses the SDK without starting ``opencode serve`` or
+calling a model::
+
+    from opencode import Opencode
+    from opencode.testing import FakeServer
+
+    fake = FakeServer(reply="Done.")
+    client = Opencode.fake(fake)  # or Opencode(transport=fake)
+
+    result = client.session.run("Fix the bug", agent="build")
+    assert result.text == "Done."
+    assert fake.prompts == ["Fix the bug"]
+
+It covers sessions (create, get, list, remove, switch agent or model), prompts, waiting, interrupts, messages,
+agents, MCP servers, server info and the event stream. Every payload is built from the generated models, so it
+has the shape the real server sends. Other routes answer ``404``. Use :meth:`FakeServer.fail` to make a route fail.
+"""
+
+from __future__ import annotations
+
+import itertools
+import json
+import os
+import re
+import time
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+from ._models import BaseModel
+from .types import (
+    AgentInfo,
+    AgentListResponse,
+    LocationPublicRef,
+    McpListResponse,
+    McpServer,
+    ModelRef,
+    ServerConnectedEvent,
+    ServerInfo,
+    SessionCreatedEvent,
+    SessionIdleEvent,
+    SessionInboxUser,
+    SessionInfo,
+    SessionInterruptResponse,
+    SessionMessageAssistant,
+    SessionMessageAssistantText,
+    SessionMessageIdle,
+    SessionMessageUser,
+    TokenUsageInfo,
+)
+
+__all__ = ["DEFAULT_MODEL", "FakeServer"]
+
+DEFAULT_MODEL = ModelRef(id="fake-model", provider_id="fake")
+"""Model reported for sessions created without one."""
+
+Reply = str | Callable[[str], str]
+"""Assistant reply: fixed text, or a function from the prompt text to the reply."""
+
+
+@dataclass
+class _Failure:
+    method: str
+    path: re.Pattern[str]
+    status: int
+    body: object
+    exception: BaseException | None
+    times: int | None
+
+
+class FakeServer(httpx.MockTransport):
+    """An in-memory OpenCode server, usable as the ``transport`` of :class:`opencode.Opencode` and
+    :class:`opencode.AsyncOpencode`.
+
+    Args:
+        reply: What the assistant answers to each prompt: text, or a function of the prompt text.
+        agents: Agent ids :meth:`opencode.Opencode.agent.list` reports. Add more later with :meth:`add_agent`.
+        mcp_servers: MCP server names mapped to their status (``connected``, ``pending``, ``failed``, ...).
+        directory: Project directory reported as every session's location.
+        cost: Cost in USD reported for each assistant reply.
+        tokens: Input and output tokens reported for each assistant reply.
+
+    Attributes:
+        sessions: Sessions by id.
+        messages: Messages of each session, oldest first.
+        events: Events the stream replays after ``server.connected``.
+        requests: Every request received, in order.
+    """
+
+    def __init__(
+        self,
+        *,
+        reply: Reply = "OK",
+        agents: Iterable[str] = ("build", "plan"),
+        mcp_servers: Mapping[str, str] | None = None,
+        directory: str = "/fake/project",
+        cost: float = 0.001,
+        tokens: tuple[int, int] = (10, 5),
+    ) -> None:
+        super().__init__(self._handle)
+        self.reply: Reply = reply
+        self.directory = directory
+        self.cost = cost
+        self.tokens = tokens
+        self.sessions: dict[str, SessionInfo] = {}
+        self.messages: dict[str, list[BaseModel]] = {}
+        self.inbox: dict[str, list[SessionInboxUser]] = {}
+        self.events: list[BaseModel] = []
+        self.requests: list[httpx.Request] = []
+        self._agents: list[tuple[str, int]] = [(agent, 0) for agent in agents]
+        self._mcp: dict[str, tuple[str, int]] = {name: (status, 0) for name, status in (mcp_servers or {}).items()}
+        self._polls = {"agent": 0, "mcp": 0}
+        self._failures: list[_Failure] = []
+        self._ids = itertools.count(1)
+
+    # -- configuration --------------------------------------------------------------------------------------
+
+    def add_agent(self, agent: str, *, after_polls: int = 0) -> None:
+        """Lists ``agent`` once ``GET /api/agent`` has been called ``after_polls`` more times, like an agent that
+        loads after boot."""
+        self._agents.append((agent, self._polls["agent"] + after_polls))
+
+    def set_mcp_status(self, name: str, status: str = "connected", *, after_polls: int = 0) -> None:
+        """Reports MCP server ``name`` with ``status`` once ``GET /api/mcp`` has been called ``after_polls`` more
+        times."""
+        self._mcp[name] = (status, self._polls["mcp"] + after_polls)
+
+    def fail(
+        self,
+        method: str,
+        path: str,
+        *,
+        status: int = 500,
+        body: object = None,
+        exception: BaseException | None = None,
+        times: int | None = 1,
+    ) -> None:
+        """Makes matching requests fail.
+
+        Args:
+            method: HTTP method, such as ``POST``.
+            path: Regular expression matched against the whole request path, such as ``/api/session/[^/]+/prompt``.
+            status: Status of the error response.
+            body: JSON error body. Defaults to an untagged body, so the error class follows ``status``.
+            exception: Raise this from the transport instead of answering, for example ``httpx.ConnectError(...)``
+                or ``KeyboardInterrupt()``.
+            times: How many requests fail; ``None`` for all of them.
+        """
+        if body is None:
+            body = {"message": f"Injected failure ({status})"}
+        self._failures.append(_Failure(method.upper(), re.compile(path), status, body, exception, times))
+
+    @property
+    def prompts(self) -> list[str]:
+        """Text of every prompt received, in order."""
+        texts: list[str] = []
+        for request in self.requests:
+            if request.method == "POST" and request.url.path.endswith("/prompt"):
+                texts.append(json.loads(request.content)["text"])
+        return texts
+
+    # -- helpers --------------------------------------------------------------------------------------------
+
+    def _id(self, prefix: str) -> str:
+        return f"{prefix}_{next(self._ids):026d}"
+
+    @staticmethod
+    def _now() -> float:
+        return float(time.time_ns() // 1_000_000)
+
+    @property
+    def _location(self) -> LocationPublicRef:
+        return LocationPublicRef(directory=self.directory)
+
+    def _session(self, session_id: str) -> SessionInfo:
+        try:
+            return self.sessions[session_id]
+        except KeyError:
+            raise _ErrorResponse(
+                404,
+                {
+                    "_tag": "SessionNotFoundError",
+                    "sessionID": session_id,
+                    "message": f"Session not found: {session_id}",
+                },
+            ) from None
+
+    @staticmethod
+    def _body(request: httpx.Request) -> dict[str, Any]:
+        if not request.content:
+            return {}
+        try:
+            payload = json.loads(request.content)
+        except ValueError:
+            raise _invalid("Request body is not JSON") from None
+        if not isinstance(payload, dict):
+            raise _invalid("Request body must be an object")
+        return dict(payload)  # pyright: ignore[reportUnknownArgumentType]
+
+    def _record(self, event: BaseModel) -> None:
+        self.events.append(event)
+
+    def _run(self, session: SessionInfo, text: str) -> None:
+        """Answers one prompt synchronously: assistant reply, idle marker, usage, events."""
+        reply = self.reply(text) if callable(self.reply) else self.reply
+        now = self._now()
+        input_tokens, output_tokens = self.tokens
+        usage = {"input": input_tokens, "output": output_tokens, "reasoning": 0, "cache": {"read": 0, "write": 0}}
+        self.messages[session.id] += [
+            SessionMessageAssistant.model_validate(
+                {
+                    "id": self._id("msg"),
+                    "type": "assistant",
+                    "time": {"created": now, "completed": now},
+                    "agent": session.agent or "build",
+                    "model": (session.model or DEFAULT_MODEL).to_dict(),
+                    "content": [SessionMessageAssistantText(type="text", text=reply).to_dict()],
+                    "finish": "stop",
+                    "cost": self.cost,
+                    "tokens": usage,
+                }
+            ),
+            SessionMessageIdle.model_validate(
+                {"id": self._id("msg"), "type": "idle", "time": {"created": now}, "outcome": "succeeded"}
+            ),
+        ]
+        session.cost += self.cost
+        session.tokens = TokenUsageInfo.model_validate(
+            {
+                "input": session.tokens.input + input_tokens,
+                "output": session.tokens.output + output_tokens,
+                "reasoning": session.tokens.reasoning,
+                "cache": session.tokens.cache.to_dict(),
+            }
+        )
+        session.outcome = "succeeded"
+        session.time.updated = session.time.idle = now
+        self._record(
+            SessionIdleEvent.model_validate(
+                {"id": self._id("evt"), "created": now, "type": "session.idle", "data": {"sessionID": session.id}}
+            )
+        )
+
+    # -- routes ---------------------------------------------------------------------------------------------
+
+    def _server_info(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        info = ServerInfo.model_validate(
+            {
+                "version": "fake",
+                "pid": os.getpid(),
+                "urls": [str(request.url.copy_with(path="/"))],
+                "paths": {"tmp": "/tmp"},
+            }
+        )
+        return _json(info)
+
+    def _agent_list(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._polls["agent"] += 1
+        visible = [agent for agent, after in self._agents if self._polls["agent"] > after]
+        agents = [
+            AgentInfo.model_validate(
+                {
+                    "id": agent,
+                    "name": agent,
+                    "mode": "primary",
+                    "hidden": False,
+                    "request": {"settings": {}, "headers": {}, "body": {}},
+                    "permissions": [],
+                }
+            )
+            for agent in dict.fromkeys(visible)
+        ]
+        return _json(AgentListResponse(location=self._location, data=agents))
+
+    def _mcp_list(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._polls["mcp"] += 1
+        servers = [
+            McpServer.model_validate(
+                {"name": name, "status": _mcp_status(status if self._polls["mcp"] > after else "pending")}
+            )
+            for name, (status, after) in self._mcp.items()
+        ]
+        return _json(McpListResponse(location=self._location, data=servers))
+
+    def _session_create(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        body = self._body(request)
+        now = self._now()
+        session_id = body.get("id") or self._id("ses")
+        if session_id in self.sessions:
+            raise _ErrorResponse(409, {"_tag": "ConflictError", "message": f"Session already exists: {session_id}"})
+        session = SessionInfo.model_validate(
+            {
+                "id": session_id,
+                "parentID": body.get("parentID"),
+                "projectID": "prj_fake",
+                "agent": body.get("agent"),
+                "model": body.get("model") or DEFAULT_MODEL.to_dict(),
+                "cost": 0,
+                "tokens": {"input": 0, "output": 0, "reasoning": 0, "cache": {"read": 0, "write": 0}},
+                "time": {"created": now, "updated": now},
+                "title": body.get("title"),
+                "metadata": body.get("metadata"),
+                "location": self._location.to_dict(),
+            }
+        )
+        self.sessions[session.id] = session
+        self.messages[session.id] = []
+        self.inbox[session.id] = []
+        self._record(
+            SessionCreatedEvent.model_validate(
+                {
+                    "id": self._id("evt"),
+                    "created": now,
+                    "type": "session.created",
+                    "durable": {"aggregate_id": session.id, "seq": 0, "version": 1},
+                    "data": {
+                        "sessionID": session.id,
+                        "projectID": session.project_id,
+                        "location": {"directory": self.directory},
+                        "slug": session.id,
+                        "title": session.title,
+                        "agent": session.agent,
+                        "version": "fake",
+                    },
+                }
+            )
+        )
+        return _json({"data": session.to_dict()})
+
+    def _session_list(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        sessions = list(self.sessions.values())
+        return _page(request, [session.to_dict() for session in sessions], newest_first_default=True)
+
+    def _session_get(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        return _json({"data": self._session(match["id"]).to_dict()})
+
+    def _session_remove(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._session(match["id"])
+        del self.sessions[match["id"]]
+        self.messages.pop(match["id"], None)
+        self.inbox.pop(match["id"], None)
+        return httpx.Response(204)
+
+    def _session_agent(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        session = self._session(match["id"])
+        agent = self._body(request).get("agent")
+        if not isinstance(agent, str):
+            raise _invalid("agent is required", field="agent")
+        session.agent = agent
+        return httpx.Response(204)
+
+    def _session_model(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        session = self._session(match["id"])
+        session.model = ModelRef.model_validate(self._body(request).get("model"))
+        return httpx.Response(204)
+
+    def _session_prompt(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        session = self._session(match["id"])
+        body = self._body(request)
+        text = body.get("text")
+        if not isinstance(text, str):
+            raise _invalid("text is required", field="text")
+        now = self._now()
+        message_id = body.get("id") or self._id("msg")
+        payload = {key: body[key] for key in ("text", "files", "agents", "skills", "metadata") if key in body}
+        queued = SessionInboxUser.model_validate(
+            {
+                "id": message_id,
+                "sessionID": session.id,
+                "time": {"created": now},
+                "type": "user",
+                "payload": payload,
+                "delivery": body.get("delivery") or "queue",
+            }
+        )
+        if body.get("resume") is False:
+            self.inbox[session.id].append(queued)
+        else:
+            self.messages[session.id].append(
+                SessionMessageUser.model_validate(
+                    {
+                        "id": message_id,
+                        "type": "user",
+                        "time": {"created": now},
+                        "text": text,
+                        "metadata": body.get("metadata"),
+                    }
+                )
+            )
+            self._run(session, text)
+        return _json({"data": queued.to_dict()})
+
+    def _session_wait(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._session(match["id"])
+        return httpx.Response(204)
+
+    def _session_interrupt(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._session(match["id"])
+        return _json(SessionInterruptResponse(interrupted=False))
+
+    def _message_list(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        self._session(match["id"])
+        wanted = request.url.params.get("type")
+        items = [
+            m.to_dict() for m in self.messages[match["id"]] if wanted is None or getattr(m, "type", None) == wanted
+        ]
+        return _page(request, items, newest_first_default=False)
+
+    def _event_stream(self, request: httpx.Request, match: re.Match[str]) -> httpx.Response:
+        connected = ServerConnectedEvent.model_validate({"id": self._id("evt"), "type": "server.connected", "data": {}})
+        chunks = [f"data: {json.dumps(event.to_dict())}\n\n" for event in [connected, *self.events]]
+        return httpx.Response(200, headers={"content-type": "text/event-stream"}, content="".join(chunks).encode())
+
+    _ROUTES: tuple[tuple[str, str, Callable[..., httpx.Response]], ...] = (
+        ("GET", r"/api/info", _server_info),
+        ("GET", r"/api/agent", _agent_list),
+        ("GET", r"/api/mcp", _mcp_list),
+        ("GET", r"/api/event", _event_stream),
+        ("POST", r"/api/session", _session_create),
+        ("GET", r"/api/session", _session_list),
+        ("GET", r"/api/session/(?P<id>[^/]+)", _session_get),
+        ("DELETE", r"/api/session/(?P<id>[^/]+)", _session_remove),
+        ("POST", r"/api/session/(?P<id>[^/]+)/agent", _session_agent),
+        ("POST", r"/api/session/(?P<id>[^/]+)/model", _session_model),
+        ("POST", r"/api/session/(?P<id>[^/]+)/prompt", _session_prompt),
+        ("POST", r"/api/session/(?P<id>[^/]+)/interrupt", _session_interrupt),
+        ("GET", r"/api/session/(?P<id>[^/]+)/message", _message_list),
+        ("POST", r"/api/experimental/session/(?P<id>[^/]+)/wait", _session_wait),
+    )
+
+    def _handle(self, request: httpx.Request) -> httpx.Response:
+        self.requests.append(request)
+        path = request.url.path
+        for failure in self._failures:
+            if failure.method == request.method and failure.path.fullmatch(path) and failure.times != 0:
+                if failure.times is not None:
+                    failure.times -= 1
+                if failure.exception is not None:
+                    raise failure.exception
+                return httpx.Response(failure.status, json=failure.body)
+        for method, pattern, handler in self._ROUTES:
+            match = re.fullmatch(pattern, path)
+            if match and method == request.method:
+                try:
+                    return handler(self, request, match)
+                except _ErrorResponse as error:
+                    return httpx.Response(error.status, json=error.body)
+        return httpx.Response(
+            404, json={"_tag": "NotFoundError", "message": f"FakeServer does not implement {request.method} {path}"}
+        )
+
+
+class _ErrorResponse(Exception):
+    def __init__(self, status: int, body: dict[str, object]) -> None:
+        super().__init__(body.get("message"))
+        self.status = status
+        self.body = body
+
+
+def _mcp_status(status: str) -> dict[str, object]:
+    if status == "failed":
+        return {"status": status, "error": "Fake MCP server failed to start"}
+    return {"status": status}
+
+
+def _invalid(message: str, *, field: str | None = None) -> _ErrorResponse:
+    return _ErrorResponse(400, {"_tag": "InvalidRequestError", "message": message, "field": field})
+
+
+def _json(payload: BaseModel | dict[str, Any]) -> httpx.Response:
+    return httpx.Response(200, json=payload.to_dict() if isinstance(payload, BaseModel) else payload)
+
+
+def _page(request: httpx.Request, items: list[dict[str, Any]], *, newest_first_default: bool) -> httpx.Response:
+    """Cursor pagination over ``items`` (oldest first). Cursors encode the order and offset, like the server's."""
+    params = request.url.params
+    cursor = params.get("cursor")
+    if cursor is not None:
+        if "order" in params:
+            return httpx.Response(
+                400, json={"_tag": "InvalidRequestError", "message": "order cannot be combined with cursor"}
+            )
+        order, _, offset_text = cursor.partition(":")
+        if order not in ("asc", "desc") or not offset_text.isdigit():
+            return httpx.Response(400, json={"_tag": "InvalidCursorError", "message": f"Invalid cursor: {cursor}"})
+        offset = int(offset_text)
+    else:
+        order = params.get("order") or ("desc" if newest_first_default else "asc")
+        offset = 0
+    limit = int(params.get("limit") or 50)
+    ordered = list(reversed(items)) if order == "desc" else items
+    data = ordered[offset : offset + limit]
+    end = offset + len(data)
+    return httpx.Response(
+        200,
+        json={
+            "data": data,
+            "cursor": {
+                "previous": f"{order}:{max(offset - limit, 0)}" if offset > 0 else None,
+                "next": f"{order}:{end}" if end < len(ordered) else None,
+            },
+        },
+    )

{opencode_python_sdk-0.1.3.dist-info → opencode_python_sdk-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: opencode-python-sdk
-Version: 0.1.3
+Version: 0.2.2
 Summary: Typed Python client for the OpenCode 2.x server API
 Project-URL: Homepage, https://github.com/shrijayan/opencode-python-sdk
 Project-URL: Documentation, https://shrijayan.github.io/opencode-python-sdk/
@@ -350,6 +350,55 @@ client.session.get("ses_...", timeout=5.0)  # per call
 
 The default timeout is 10 minutes with a 10 second connect timeout.
 
+## Running an agent headless
+
+`client.session.run` does the usual "prompt an agent and wait" round trip in one call: it creates a session (or
+reuses `session_id`), sends the prompt, blocks until the session is idle, and returns the new messages with the
+final text and usage. `client.wait_until_ready` waits until agents and MCP servers have loaded, which happens
+asynchronously after the server boots. Both have async versions on `AsyncOpencode`.
+
+```python
+from opencode import Opencode
+from opencode.types import ModelRef, PromptInputFileAttachment
+
+with Opencode("http://127.0.0.1:4096", password="...") as client:
+    client.wait_until_ready(agents=["reviewer"], mcp_servers=["github"], timeout=60)
+    result = client.session.run(
+        "Review the attached diff",
+        agent="reviewer",
+        model=ModelRef(provider_id="anthropic", id="claude-sonnet-5-5"),  # set it with the agent
+        files=[PromptInputFileAttachment(uri="data:text/plain;base64,...", name="diff.patch")],
+        timeout=600,
+    )
+    print(result.outcome, result.text)
+    print(result.cost, result.tokens.input, result.tokens.output)  # this run; result.session has the totals
+```
+
+If the wait ends early (Ctrl-C, task cancellation, `timeout`, a connection error), `run` interrupts the session
+on the server before re-raising, so the agent does not keep running unattended.
+
+## Testing your code
+
+`opencode.testing.FakeServer` is an in-process fake of the server: an `httpx` transport that keeps sessions,
+messages and events in memory and answers with the same payloads as the real server. No process, no model.
+
+```python
+from opencode import Opencode
+from opencode.testing import FakeServer
+
+
+def test_summarize() -> None:
+    fake = FakeServer(reply=lambda prompt: f"summary of {prompt!r}")
+    client = Opencode.fake(fake)  # same as Opencode(transport=fake)
+
+    assert client.session.run("README").text == "summary of 'README'"
+    assert fake.prompts == ["README"]
+```
+
+`fake.fail(method, path_regex, status=..., exception=...)` injects errors, `fake.add_agent(..., after_polls=n)`
+and `fake.set_mcp_status(...)` simulate slow boots, and `fake.requests` records every request. Routes the fake
+does not implement answer `404`.
+
 ## Running a server
 
 `OpencodeServer` runs `opencode serve` as a child process on a free local port with a random password:
@@ -370,6 +419,27 @@ with server:
 The server runs in `--stdio` mode, so it also exits when the Python process dies. `AsyncOpencodeServer` is the
 async equivalent.
 
+### The background service
+
+OpenCode can also run one shared background server per user (`opencode serve --service`), which registers itself in
+`$XDG_STATE_HOME/opencode/service.json`. `Opencode.from_service()` connects to it, starting it first if it is not
+running:
+
+```python
+from opencode import Opencode, service
+
+with Opencode.from_service(version="2.1.2") as client:  # replaces a service running another version
+    print(client.server.info().version)
+
+endpoint = service.discover()  # an Endpoint, or None; never starts anything
+service.stop(pty="handoff")  # hand persistent terminals to the next service instead of closing them
+```
+
+`service.ensure()` returns the `Endpoint` (URL and credentials) without creating a client, and `service.headers()`
+gives its `Authorization` header for other HTTP clients. Concurrent callers are safe: they race to start the service
+and all get the one that won. `await AsyncOpencode.from_service()`, `service.async_discover()`,
+`service.async_ensure()` and `service.async_stop()` are the async equivalents.
+
 ## Advanced
 
 ```python

opencode_python_sdk-0.2.2.dist-info/RECORD

@@ -0,0 +1,64 @@
+opencode/.generated.json,sha256=QNCFazAYhcwsGf0l4A2EeSpm2HOM7TRBE648Zyoeq_s,1383
+opencode/__init__.py,sha256=ZknWy2NBxHe4C6prS9gW56FBu2UoV-OLcMsMY4hnEKI,5759
+opencode/_base_client.py,sha256=oA7Yah1WYyw16WrF_x76T1uZE5Arwt4jQMK8gyrL_4Y,21008
+opencode/_client.py,sha256=nUkvwHuKRpISQgy4-d9c62nq9zMtzENsuqbQE4KKwAw,15402
+opencode/_constants.py,sha256=-B_D8RHElL4mYN__WVf4bag4D12dJHbL69_EMfi7bXo,1132
+opencode/_errors.py,sha256=dWjsyGV0aDBKsvJrGNKGJn41Yue66yBBwGTT2pTV7E8,16431
+opencode/_events.py,sha256=Pg6zgPT37GHRITM5HvuxC6hmdZVrd2msyfsFQPoOAcQ,30179
+opencode/_exceptions.py,sha256=kqQiaSM6zbfyiXXddwapIymW7J61ZlAa767Yko5Y9EI,8720
+opencode/_models.py,sha256=2esvD2CmslOHCbuLNkN0sGDcgMAqeoMmB7hZMPzo1uA,1988
+opencode/_pagination.py,sha256=uvB-0IwfkGqbYIYiUW_ax_oAE-ldZJSWHtjluVcZlNk,7052
+opencode/_pty.py,sha256=wdqBF7K40ikzas8i203pem2iov8nbgYDC-RqH6ZX41E,23429
+opencode/_qs.py,sha256=8EWbLzd-iLComngGRyO95f_z76j4tUeBihYJdHI5NP8,3643
+opencode/_resource.py,sha256=ovuG85mWcuXNTu5m6H9FKPN2rrD5o52oRFAGBHimPyg,1263
+opencode/_rpc.py,sha256=WrPQ_hRhsneXLvYj7WwEADC6_OCMRE5muuWVoysKPok,17708
+opencode/_server.py,sha256=O-yVWU-v7HDJuVav1xXTil96BtvvbYMsHm1zLhneWKk,12849
+opencode/_service.py,sha256=LtkGdZBbRH6I7F6PYnzMNNOqXudze_Uy3HO_ghnCPf4,36622
+opencode/_streaming.py,sha256=TfnfZaNucjLrpfOB9m1i_sRtjYoACztTflavrhwvnDE,8861
+opencode/_types.py,sha256=Z8bYxzpZhPRtisvPUv9R5g4oBlC23iXR70fFzReTOc0,2194
+opencode/_unions.py,sha256=dW0dTmP2QK2lL6RhyK2YsjD2yNbO8Ah6pk-i5ySW3lo,1518
+opencode/_version.py,sha256=zNErHu8z_g6ScOeYcO8QAiktg036FVPaUiIIZefeoLU,259
+opencode/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencode/service.py,sha256=kFjQ4mjV30-VXx5B22ZPUs0V0e__fyTZ2Yj2VAoUrbU,921
+opencode/testing.py,sha256=_EGoh9SwC5WCwbXjm5AtbyAzB4zyO5xX2N-skMLHzR4,21069
+opencode/lib/__init__.py,sha256=mWBVu6RUOqMNJHHZPLq2nkks7QdsWJgLPN44BmfDv9s,120
+opencode/lib/_ready.py,sha256=dhX-n6DDjRWsYJ95paxt1i5WnlU_KsFsTqgkJEt01Q4,3286
+opencode/lib/_session.py,sha256=SCmBOYWdDyoCGKJ5YF2eQPxu8R0TmVhcV4C_xl1jFKA,9212
+opencode/resources/__init__.py,sha256=wNPQqEDgNYedtWhub2wVWL85jEoE2qCQQHks5WHyAoM,13239
+opencode/resources/agent.py,sha256=6vQC__e3cZxkJG-Xeqj66wh4kH1zOpGS9662N2dSa3s,5624
+opencode/resources/command.py,sha256=60itt-z1mhUlJEHY7aUy6kUerIdostbhZf7y0I6EK74,3073
+opencode/resources/config.py,sha256=L6FbrXeegplUsTjHQZX1KsAaGA0Yy0_w8MP8V5dRo7Q,7699
+opencode/resources/credential.py,sha256=Z464vfgOSXMB-pi4LCCnUR4mWRtmFpefqlZ9rWQP_Fk,12084
+opencode/resources/debug.py,sha256=sZvMb7WsiB65O-B3-U4DablrUWctOOvd6BWY_t6SW3w,5537
+opencode/resources/event.py,sha256=zsaY6bmBt5zYCxxghJzWCyG342_2uAAP1xsVgyTaYwc,2763
+opencode/resources/experimental.py,sha256=zfIBB_4TtVdFqBgksk5jmQ-9a_5hpPhPRT1f0vlPQoY,28172
+opencode/resources/file.py,sha256=3J06QXIQT5_WLdPse3OLQqMN8ypCR6VsadndAQnHQEg,13013
+opencode/resources/form.py,sha256=Lc4Ko_01ABZZTIQi8UOfmSO_xfhWP8UoAr5wBUNdAqY,3021
+opencode/resources/generate.py,sha256=RFjg4dBXDhzhxGz5bO50igZZ5-W7bT6PIEw_ED45Su0,3809
+opencode/resources/integration.py,sha256=q59coZDkdVcRk53q3wwffrySYAsPT_GMIjbirT7aAXY,37919
+opencode/resources/location.py,sha256=Idd0K174jkzJvpEqoucSII1sP8ibuHZIfsz6X5id8_U,5357
+opencode/resources/mcp.py,sha256=aC6jLoS18Ez_4nMRsUmxbMGSR2jGFMAPurRuoPKFL10,16401
+opencode/resources/message.py,sha256=D5IF_mAD2GnFH8_Ggy7tEXECsm6Jx6dt3CO0haGPfic,5971
+opencode/resources/migration.py,sha256=aqwIG6vcFZ1zzKwRR731ZOpLJeUMG7E9f1dIc8YOR4o,4252
+opencode/resources/model.py,sha256=1SXCA7r6rukxUC6iar9I33Zs01gNGl92-J3p1LfRo38,5875
+opencode/resources/permission.py,sha256=KjcppKC5VwYFB8RvrOO8-tAcERyQtMd-IvNQn-lOigY,24528
+opencode/resources/plugin.py,sha256=_wa0UfT-_TGgE1lo3nkODXjyb26EXXB_WHgX8DTcGVQ,8221
+opencode/resources/project.py,sha256=HfMDFqKbpzPqmmKg4WAxkM7_J7RfWr1QiWBKuZg-CPU,6184
+opencode/resources/provider.py,sha256=f0z-nLqtGzvHSGIHj7LR7eVzLTT60D6Jw2aR7IkMtWs,6200
+opencode/resources/pty.py,sha256=dReNx2ETWMhJHmZ53x4JhkkjXRWxVP_kfa5eQYlo3EU,17631
+opencode/resources/reference.py,sha256=ovKtRm4vCMD0ulWJncXZIkuCQacBDQYKwOk5QOOHjMg,3143
+opencode/resources/rpc.py,sha256=aBTeAvDyBK5NQeO-Yt9mZrqiOB4u4_8dQD082t4pO9s,3684
+opencode/resources/server.py,sha256=Vr-uTexG20gtt53c23ny-iGy_BeXYCKJWAnu0P6Uauc,6998
+opencode/resources/session.py,sha256=xQXN9_Af3OIlqEDQZPSCiByZkyn3ZXut9GD041Yk0ig,126883
+opencode/resources/shell.py,sha256=-VzSkaVOaVM1GZdjM2rz9mAWffg9fnxy9KCseYzti-I,13911
+opencode/resources/skill.py,sha256=R44XZaWeSyVZNbHHVUnLsqL81Mlg1cvqMkTYqHSRv_c,3025
+opencode/resources/vcs.py,sha256=vZzdowfs4CbCMDDQ_uF48d5P4ym8qw4DZ3Q-_sjbDw8,17811
+opencode/resources/voice.py,sha256=cM3eEBopD-DSfwPdiuwSzapeGZyvhroCA97WRrLXXT0,3988
+opencode/resources/websearch.py,sha256=hqXcTPq-lGnqB34VMcFL59KbS2vvfwd-JntgUozKAw4,6271
+opencode/resources/worktree.py,sha256=rRDysFG4zncjlIgjkwxT2UKkUgLXMr2DxeEfg5j2YrE,11016
+opencode/types/__init__.py,sha256=5JEAe89RPSwJw1yz0kufBxtEJgRsMpZXj7KTbzGX45A,60935
+opencode/types/_generated.py,sha256=c3zBAfVpZGJ9TX4FqrMZASmoxRntel_QzVuP85BOJwU,235015
+opencode_python_sdk-0.2.2.dist-info/METADATA,sha256=d8EuoMpm4YOLAqDLpupbnPDrHbOJEZXln6pLYfELqrs,19023
+opencode_python_sdk-0.2.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+opencode_python_sdk-0.2.2.dist-info/licenses/LICENSE,sha256=SbiOG1an_-gZ0gwGLS0tsbUnMHA7tYX22FgP1EqzrH4,1093
+opencode_python_sdk-0.2.2.dist-info/RECORD,,