daimon-sdk 0.1.0__py3-none-any.whl

daimon_sdk/__init__.py

@@ -0,0 +1,35 @@
+from .client import DaimonClient
+from .exceptions import (
+    DaimonConnectionError,
+    DaimonError,
+    DaimonProtocolError,
+    DaimonToolError,
+)
+from .models import (
+    BashResult,
+    EditResult,
+    ExecResult,
+    GlobResult,
+    GrepResult,
+    RuntimeContextResult,
+    SessionHandle,
+    WebFetchResult,
+    WriteResult,
+)
+
+__all__ = [
+    "BashResult",
+    "EditResult",
+    "ExecResult",
+    "GlobResult",
+    "GrepResult",
+    "DaimonClient",
+    "DaimonConnectionError",
+    "DaimonError",
+    "DaimonProtocolError",
+    "DaimonToolError",
+    "RuntimeContextResult",
+    "SessionHandle",
+    "WebFetchResult",
+    "WriteResult",
+]

daimon_sdk/_transport.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+from fastmcp import Client
+from fastmcp.client.transports import StreamableHttpTransport
+
+from .exceptions import DaimonConnectionError, DaimonProtocolError, DaimonToolError
+
+
+@dataclass(slots=True)
+class ToolCallEnvelope:
+    tool_name: str
+    payload: dict[str, Any]
+    content_blocks: list[dict[str, Any]]
+    raw_result: Any
+
+
+def _content_block_to_dict(block: Any) -> dict[str, Any]:
+    if isinstance(block, dict):
+        return dict(block)
+    data: dict[str, Any] = {}
+    for key in ("type", "text", "data", "mimeType", "mime_type", "annotations"):
+        value = getattr(block, key, None)
+        if value is not None:
+            data[key] = value
+    if not data and hasattr(block, "model_dump"):
+        dumped = block.model_dump()
+        if isinstance(dumped, dict):
+            data = dumped
+    if not data and hasattr(block, "__dict__"):
+        data = {
+            key: value
+            for key, value in vars(block).items()
+            if not key.startswith("_")
+        }
+    return data
+
+
+def decode_tool_result(result: Any) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    if isinstance(getattr(result, "structured_content", None), dict):
+        payload = dict(result.structured_content)
+        content = [_content_block_to_dict(block) for block in getattr(result, "content", []) or []]
+        return payload, content
+    if getattr(result, "data", None) is not None:
+        data = result.data
+        if isinstance(data, dict):
+            payload = dict(data)
+        elif isinstance(data, str):
+            try:
+                payload = json.loads(data)
+            except json.JSONDecodeError as exc:
+                raise DaimonProtocolError(f"tool response data was not valid JSON: {data}") from exc
+        else:
+            raise DaimonProtocolError(f"unsupported tool response data type: {type(data)!r}")
+        content = [_content_block_to_dict(block) for block in getattr(result, "content", []) or []]
+        return payload, content
+    content = getattr(result, "content", None) or []
+    if content:
+        text = getattr(content[0], "text", None)
+        if isinstance(text, str):
+            try:
+                payload = json.loads(text)
+            except json.JSONDecodeError as exc:
+                raise DaimonProtocolError(f"tool response text was not valid JSON: {text}") from exc
+            return payload, [_content_block_to_dict(block) for block in content]
+    raise DaimonProtocolError(f"unable to decode tool result: {result!r}")
+
+
+class FastMCPTransportAdapter:
+    def __init__(self, base_url: str, *, access_token: str | None, timeout_s: float) -> None:
+        self.base_url = base_url
+        self.access_token = access_token
+        self.timeout_s = timeout_s
+        self._client: Client | None = None
+
+    @property
+    def client(self) -> Client:
+        if self._client is None:
+            raise DaimonConnectionError("client is not connected")
+        return self._client
+
+    async def connect(self) -> None:
+        if self._client is not None:
+            return
+        headers = {"X-Access-Token": self.access_token} if self.access_token else None
+        transport = StreamableHttpTransport(
+            self.base_url,
+            headers=headers,
+            httpx_client_factory=self._httpx_client_factory,
+        )
+        client = Client(transport, timeout=self.timeout_s)
+        try:
+            await client.__aenter__()
+        except Exception as exc:  # pragma: no cover - fastmcp exception types vary
+            raise DaimonConnectionError(str(exc)) from exc
+        self._client = client
+
+    async def close(self) -> None:
+        if self._client is None:
+            return
+        try:
+            await self._client.__aexit__(None, None, None)
+        finally:
+            self._client = None
+
+    async def call_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        *,
+        raise_on_error: bool = True,
+    ) -> ToolCallEnvelope:
+        await self.connect()
+        try:
+            result = await self.client.call_tool(tool_name, arguments, raise_on_error=False)
+        except Exception as exc:  # pragma: no cover - transport-side failures vary
+            raise DaimonConnectionError(str(exc)) from exc
+        payload, content_blocks = decode_tool_result(result)
+        if raise_on_error and isinstance(payload.get("error"), str):
+            raise DaimonToolError(payload["error"], tool_name=tool_name, payload=payload)
+        return ToolCallEnvelope(
+            tool_name=tool_name,
+            payload=payload,
+            content_blocks=content_blocks,
+            raw_result=result,
+        )
+
+    def _httpx_client_factory(self, **kwargs: Any) -> httpx.AsyncClient:
+        headers = dict(kwargs.pop("headers", {}) or {})
+        kwargs.setdefault("timeout", self.timeout_s)
+        kwargs.setdefault("follow_redirects", True)
+        return httpx.AsyncClient(headers=headers, **kwargs)

daimon_sdk/client.py

@@ -0,0 +1,437 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._transport import FastMCPTransportAdapter, ToolCallEnvelope
+from .models import (
+    BashResult,
+    ContentBlock,
+    EditResult,
+    ExecResult,
+    GlobResult,
+    GrepResult,
+    ReadImageFile,
+    ReadPartsFile,
+    ReadResult,
+    ReadTextFile,
+    RuntimeContextResult,
+    SessionHandle,
+    WebFetchResult,
+    WriteResult,
+)
+
+
+def _content_blocks(envelope: ToolCallEnvelope) -> list[ContentBlock]:
+    return [ContentBlock.from_dict(block) for block in envelope.content_blocks]
+
+
+def _int_or_none(value: Any) -> int | None:
+    if isinstance(value, bool):
+        return int(value)
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.isdigit():
+        return int(value)
+    return None
+
+
+class RawAPI:
+    def __init__(self, client: "DaimonClient") -> None:
+        self._client = client
+
+    async def call_tool(
+        self,
+        name: str,
+        arguments: dict[str, Any] | None = None,
+        *,
+        raise_on_error: bool = True,
+    ) -> dict[str, Any]:
+        envelope = await self._client._call_tool(
+            name,
+            arguments or {},
+            raise_on_error=raise_on_error,
+        )
+        return envelope.payload
+
+
+class RuntimeAPI:
+    def __init__(self, client: "DaimonClient") -> None:
+        self._client = client
+
+    async def get_context(self) -> RuntimeContextResult:
+        envelope = await self._client._call_tool("GetRuntimeContext", {})
+        return RuntimeContextResult(payload=envelope.payload)
+
+
+class FilesAPI:
+    def __init__(self, client: "DaimonClient") -> None:
+        self._client = client
+
+    async def read(
+        self,
+        file_path: str,
+        *,
+        offset: int | None = None,
+        limit: int | None = None,
+        pages: str | None = None,
+    ) -> ReadResult:
+        arguments: dict[str, Any] = {"file_path": file_path}
+        if offset is not None:
+            arguments["offset"] = offset
+        if limit is not None:
+            arguments["limit"] = limit
+        if pages is not None:
+            arguments["pages"] = pages
+        envelope = await self._client._call_tool("Read", arguments)
+        payload = envelope.payload
+        kind = payload.get("type")
+        file_data = payload.get("file") or {}
+        if kind == "text":
+            file_model = ReadTextFile(
+                file_path=file_data["filePath"],
+                content=file_data["content"],
+                num_lines=file_data["numLines"],
+                start_line=file_data["startLine"],
+                total_lines=file_data["totalLines"],
+            )
+        elif kind == "image":
+            file_model = ReadImageFile(
+                file_path=file_data["filePath"],
+                mime_type=file_data["mimeType"],
+            )
+        elif kind == "parts":
+            file_model = ReadPartsFile(
+                file_path=file_data["filePath"],
+                count=file_data["count"],
+                pages=file_data["pages"],
+            )
+        else:
+            raise ValueError(f"unsupported read result type: {kind!r}")
+        return ReadResult(
+            kind=kind,
+            file=file_model,
+            extra_content=_content_blocks(envelope),
+            raw_payload=payload,
+        )
+
+    async def edit(
+        self,
+        file_path: str,
+        *,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,
+    ) -> EditResult:
+        envelope = await self._client._call_tool(
+            "Edit",
+            {
+                "file_path": file_path,
+                "old_string": old_string,
+                "new_string": new_string,
+                "replace_all": replace_all,
+            },
+        )
+        payload = envelope.payload
+        return EditResult(
+            file_path=payload["filePath"],
+            old_string=payload["oldString"],
+            new_string=payload["newString"],
+            original_file=payload["originalFile"],
+            structured_patch=payload["structuredPatch"],
+            user_modified=payload["userModified"],
+            replace_all=payload["replaceAll"],
+            git_diff=payload.get("gitDiff"),
+            raw_payload=payload,
+        )
+
+    async def write(self, file_path: str, content: str) -> WriteResult:
+        envelope = await self._client._call_tool(
+            "Write",
+            {"file_path": file_path, "content": content},
+        )
+        payload = envelope.payload
+        return WriteResult(
+            type=payload["type"],
+            file_path=payload["filePath"],
+            content=payload["content"],
+            structured_patch=payload["structuredPatch"],
+            original_file=payload.get("originalFile"),
+            git_diff=payload.get("gitDiff"),
+            raw_payload=payload,
+        )
+
+    async def glob(self, pattern: str, *, path: str | None = None) -> GlobResult:
+        arguments: dict[str, Any] = {"pattern": pattern}
+        if path is not None:
+            arguments["path"] = path
+        envelope = await self._client._call_tool("Glob", arguments)
+        payload = envelope.payload
+        return GlobResult(
+            search_path=payload["searchPath"],
+            filenames=list(payload["filenames"]),
+            num_files=payload["numFiles"],
+            truncated=payload["truncated"],
+            duration_ms=payload["durationMs"],
+            raw_payload=payload,
+        )
+
+    async def grep(
+        self,
+        pattern: str,
+        *,
+        path: str | None = None,
+        glob: str | None = None,
+        output_mode: str | None = None,
+        before: int | None = None,
+        after: int | None = None,
+        context_n: int | None = None,
+        context: int | None = None,
+        line_number: bool | None = None,
+        ignore_case: bool | None = None,
+        file_type: str | None = None,
+        head_limit: int | None = None,
+        offset: int | None = None,
+        multiline: bool | None = None,
+    ) -> GrepResult:
+        arguments: dict[str, Any] = {"pattern": pattern}
+        optional_values = {
+            "path": path,
+            "glob": glob,
+            "output_mode": output_mode,
+            "-B": before,
+            "-A": after,
+            "-C": context_n,
+            "context": context,
+            "-n": line_number,
+            "-i": ignore_case,
+            "type": file_type,
+            "head_limit": head_limit,
+            "offset": offset,
+            "multiline": multiline,
+        }
+        for key, value in optional_values.items():
+            if value is not None:
+                arguments[key] = value
+        envelope = await self._client._call_tool("Grep", arguments)
+        payload = envelope.payload
+        return GrepResult(
+            mode=payload["mode"],
+            filenames=list(payload["filenames"]),
+            num_files=payload["numFiles"],
+            content=payload.get("content"),
+            num_lines=payload.get("numLines"),
+            num_matches=payload.get("numMatches"),
+            applied_limit=payload.get("appliedLimit"),
+            applied_offset=payload.get("appliedOffset"),
+            raw_payload=payload,
+        )
+
+
+class ExecAPI:
+    def __init__(self, client: "DaimonClient") -> None:
+        self._client = client
+
+    async def bash(
+        self,
+        command: str,
+        *,
+        timeout_ms: int | None = None,
+        description: str | None = None,
+        run_in_background: bool = False,
+        dangerously_disable_sandbox: bool = False,
+    ) -> BashResult:
+        arguments: dict[str, Any] = {
+            "command": command,
+            "run_in_background": run_in_background,
+            "dangerouslyDisableSandbox": dangerously_disable_sandbox,
+        }
+        if timeout_ms is not None:
+            arguments["timeout"] = timeout_ms
+        if description is not None:
+            arguments["description"] = description
+        envelope = await self._client._call_tool("Bash", arguments)
+        payload = envelope.payload
+        return BashResult(
+            stdout=payload["stdout"],
+            stderr=payload["stderr"],
+            interrupted=payload["interrupted"],
+            dangerously_disable_sandbox=payload["dangerouslyDisableSandbox"],
+            persisted_output_path=payload.get("persistedOutputPath"),
+            persisted_output_size=payload.get("persistedOutputSize"),
+            background_task_id=payload.get("backgroundTaskId"),
+            raw_payload=payload,
+        )
+
+    async def exec_command(
+        self,
+        cmd: str,
+        *,
+        workdir: str | None = None,
+        shell: str | None = None,
+        tty: bool = False,
+        yield_time_ms: int | None = None,
+        max_output_tokens: int | None = None,
+        login: bool | None = None,
+        sandbox_permissions: str | None = None,
+        justification: str | None = None,
+        prefix_rule: list[str] | None = None,
+    ) -> ExecResult:
+        arguments: dict[str, Any] = {"cmd": cmd, "tty": tty}
+        optional_values = {
+            "workdir": workdir,
+            "shell": shell,
+            "yield_time_ms": yield_time_ms,
+            "max_output_tokens": max_output_tokens,
+            "login": login,
+            "sandbox_permissions": sandbox_permissions,
+            "justification": justification,
+            "prefix_rule": prefix_rule,
+        }
+        for key, value in optional_values.items():
+            if value is not None:
+                arguments[key] = value
+        envelope = await self._client._call_tool("exec_command", arguments)
+        return self._exec_from_payload(envelope.payload)
+
+    async def start_session(
+        self,
+        cmd: str,
+        *,
+        workdir: str | None = None,
+        shell: str | None = None,
+        tty: bool = False,
+        yield_time_ms: int | None = None,
+        max_output_tokens: int | None = None,
+        login: bool | None = None,
+        sandbox_permissions: str | None = None,
+        justification: str | None = None,
+        prefix_rule: list[str] | None = None,
+    ) -> SessionHandle:
+        result = await self.exec_command(
+            cmd,
+            workdir=workdir,
+            shell=shell,
+            tty=tty,
+            yield_time_ms=yield_time_ms,
+            max_output_tokens=max_output_tokens,
+            login=login,
+            sandbox_permissions=sandbox_permissions,
+            justification=justification,
+            prefix_rule=prefix_rule,
+        )
+        if result.session_id is None:
+            raise RuntimeError("processd did not return a running session")
+        return SessionHandle(self._client, result.session_id)
+
+    async def write_stdin(
+        self,
+        session_id: int,
+        *,
+        chars: str = "",
+        yield_time_ms: int | None = None,
+        max_output_tokens: int | None = None,
+    ) -> ExecResult:
+        arguments: dict[str, Any] = {"session_id": session_id, "chars": chars}
+        if yield_time_ms is not None:
+            arguments["yield_time_ms"] = yield_time_ms
+        if max_output_tokens is not None:
+            arguments["max_output_tokens"] = max_output_tokens
+        envelope = await self._client._call_tool("write_stdin", arguments)
+        return self._exec_from_payload(envelope.payload)
+
+    @staticmethod
+    def _exec_from_payload(payload: dict[str, Any]) -> ExecResult:
+        return ExecResult(
+            output=payload.get("output", ""),
+            wall_time_seconds=float(payload.get("wall_time_seconds", 0.0)),
+            chunk_id=str(payload.get("chunk_id", "")),
+            original_token_count=int(payload.get("original_token_count", 0)),
+            session_id=_int_or_none(payload.get("session_id")),
+            exit_code=_int_or_none(payload.get("exit_code")),
+            raw_payload=payload,
+        )
+
+
+class WebAPI:
+    def __init__(self, client: "DaimonClient") -> None:
+        self._client = client
+
+    async def fetch(
+        self,
+        url: str,
+        *,
+        timeout_ms: int | None = None,
+        max_bytes: int | None = None,
+        follow_same_host_redirects: bool | None = None,
+    ) -> WebFetchResult:
+        arguments: dict[str, Any] = {"url": url}
+        if timeout_ms is not None:
+            arguments["timeout_ms"] = timeout_ms
+        if max_bytes is not None:
+            arguments["max_bytes"] = max_bytes
+        if follow_same_host_redirects is not None:
+            arguments["follow_same_host_redirects"] = follow_same_host_redirects
+        envelope = await self._client._call_tool("WebFetch", arguments)
+        payload = envelope.payload
+        return WebFetchResult(
+            url=payload["url"],
+            status_code=payload["statusCode"],
+            content_type=payload["contentType"],
+            bytes=payload["bytes"],
+            result_type=payload["resultType"],
+            content=payload["content"],
+            redirect_url=payload.get("redirectUrl"),
+            persisted_path=payload.get("persistedPath"),
+            persisted_size=payload.get("persistedSize"),
+            duration_ms=payload["durationMs"],
+            raw_payload=payload,
+        )
+
+
+class DaimonClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        access_token: str | None = None,
+        timeout_s: float = 30.0,
+    ) -> None:
+        self.base_url = base_url
+        self.access_token = access_token
+        self.timeout_s = timeout_s
+        self._transport = FastMCPTransportAdapter(
+            base_url,
+            access_token=access_token,
+            timeout_s=timeout_s,
+        )
+        self.raw = RawAPI(self)
+        self.runtime = RuntimeAPI(self)
+        self.files = FilesAPI(self)
+        self.exec = ExecAPI(self)
+        self.web = WebAPI(self)
+
+    async def connect(self) -> "DaimonClient":
+        await self._transport.connect()
+        return self
+
+    async def close(self) -> None:
+        await self._transport.close()
+
+    async def __aenter__(self) -> "DaimonClient":
+        return await self.connect()
+
+    async def __aexit__(self, exc_type: object, exc: object, tb: object) -> None:
+        await self.close()
+
+    async def _call_tool(
+        self,
+        tool_name: str,
+        arguments: dict[str, Any],
+        *,
+        raise_on_error: bool = True,
+    ) -> ToolCallEnvelope:
+        return await self._transport.call_tool(
+            tool_name,
+            arguments,
+            raise_on_error=raise_on_error,
+        )

daimon_sdk/exceptions.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class DaimonError(Exception):
+    """Base SDK error."""
+
+
+class DaimonConnectionError(DaimonError):
+    """Raised when the SDK cannot connect to the MCP endpoint."""
+
+
+class DaimonProtocolError(DaimonError):
+    """Raised when the MCP response cannot be decoded into a processd payload."""
+
+
+class DaimonToolError(DaimonError):
+    """Raised when processd returns a structured tool error."""
+
+    def __init__(self, message: str, *, tool_name: str, payload: dict[str, Any] | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.tool_name = tool_name
+        self.payload = payload or {}

daimon_sdk/models.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .client import DaimonClient
+
+
+@dataclass(slots=True)
+class ContentBlock:
+    type: str | None
+    text: str | None = None
+    mime_type: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, payload: dict[str, Any]) -> "ContentBlock":
+        return cls(
+            type=payload.get("type"),
+            text=payload.get("text"),
+            mime_type=payload.get("mimeType") or payload.get("mime_type"),
+            raw=payload,
+        )
+
+
+@dataclass(slots=True)
+class ReadTextFile:
+    file_path: str
+    content: str
+    num_lines: int
+    start_line: int
+    total_lines: int
+
+
+@dataclass(slots=True)
+class ReadImageFile:
+    file_path: str
+    mime_type: str
+
+
+@dataclass(slots=True)
+class ReadPartsFile:
+    file_path: str
+    count: int
+    pages: str
+
+
+@dataclass(slots=True)
+class ReadResult:
+    kind: str
+    file: ReadTextFile | ReadImageFile | ReadPartsFile
+    extra_content: list[ContentBlock]
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class EditResult:
+    file_path: str
+    old_string: str
+    new_string: str
+    original_file: str
+    structured_patch: list[dict[str, Any]]
+    user_modified: bool
+    replace_all: bool
+    git_diff: dict[str, Any] | None
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class WriteResult:
+    type: str
+    file_path: str
+    content: str
+    structured_patch: list[dict[str, Any]]
+    original_file: str | None
+    git_diff: dict[str, Any] | None
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class GlobResult:
+    search_path: str
+    filenames: list[str]
+    num_files: int
+    truncated: bool
+    duration_ms: int
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class GrepResult:
+    mode: str
+    filenames: list[str]
+    num_files: int
+    content: str | None
+    num_lines: int | None
+    num_matches: int | None
+    applied_limit: int | None
+    applied_offset: int | None
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class ExecResult:
+    output: str
+    wall_time_seconds: float
+    chunk_id: str
+    original_token_count: int
+    session_id: int | None
+    exit_code: int | None
+    raw_payload: dict[str, Any]
+
+    @property
+    def is_running(self) -> bool:
+        return self.session_id is not None and self.exit_code is None
+
+    @property
+    def has_exited(self) -> bool:
+        return self.exit_code is not None
+
+
+@dataclass(slots=True)
+class BashResult:
+    stdout: str
+    stderr: str
+    interrupted: bool
+    dangerously_disable_sandbox: bool
+    persisted_output_path: str | None
+    persisted_output_size: int | None
+    background_task_id: str | None
+    raw_payload: dict[str, Any]
+
+    @property
+    def is_background(self) -> bool:
+        return self.background_task_id is not None
+
+
+@dataclass(slots=True)
+class WebFetchResult:
+    url: str
+    status_code: int
+    content_type: str
+    bytes: int
+    result_type: str
+    content: str
+    redirect_url: str | None
+    persisted_path: str | None
+    persisted_size: int | None
+    duration_ms: int
+    raw_payload: dict[str, Any]
+
+
+@dataclass(slots=True)
+class RuntimeContextResult:
+    payload: dict[str, Any]
+
+    @property
+    def base_workdir(self) -> str | None:
+        return self.payload.get("baseWorkdir")
+
+    @property
+    def summary(self) -> str | None:
+        value = self.payload.get("summary")
+        return value if isinstance(value, str) else None
+
+    @property
+    def filesystem(self) -> dict[str, Any]:
+        value = self.payload.get("filesystem")
+        return value if isinstance(value, dict) else {}
+
+    @property
+    def network(self) -> dict[str, Any]:
+        value = self.payload.get("network")
+        return value if isinstance(value, dict) else {}
+
+
+@dataclass(slots=True)
+class SessionHandle:
+    _client: "DaimonClient"
+    session_id: int
+
+    async def write(
+        self,
+        chars: str = "",
+        *,
+        yield_time_ms: int | None = None,
+        max_output_tokens: int | None = None,
+    ) -> ExecResult:
+        return await self._client.exec.write_stdin(
+            self.session_id,
+            chars=chars,
+            yield_time_ms=yield_time_ms,
+            max_output_tokens=max_output_tokens,
+        )
+
+    async def poll(
+        self,
+        *,
+        yield_time_ms: int | None = None,
+        max_output_tokens: int | None = None,
+    ) -> ExecResult:
+        return await self.write(
+            "",
+            yield_time_ms=yield_time_ms,
+            max_output_tokens=max_output_tokens,
+        )
+
+    async def wait_for_exit(
+        self,
+        *,
+        timeout_s: float = 10.0,
+        yield_time_ms: int = 5_000,
+        poll_interval_s: float = 0.05,
+        max_output_tokens: int | None = None,
+    ) -> ExecResult:
+        deadline = time.monotonic() + timeout_s
+        last_result: ExecResult | None = None
+        while time.monotonic() < deadline:
+            last_result = await self.poll(
+                yield_time_ms=yield_time_ms,
+                max_output_tokens=max_output_tokens,
+            )
+            if last_result.has_exited:
+                return last_result
+            await asyncio.sleep(poll_interval_s)
+        raise TimeoutError(f"session {self.session_id} did not exit within {timeout_s} seconds")
+
+    async def close(
+        self,
+        *,
+        exit_payload: str = "__EXIT__\n",
+        yield_time_ms: int = 500,
+        max_output_tokens: int | None = None,
+    ) -> ExecResult:
+        return await self.write(
+            exit_payload,
+            yield_time_ms=yield_time_ms,
+            max_output_tokens=max_output_tokens,
+        )

daimon_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: daimon-sdk
+Version: 0.1.0
+Summary: Typed async Python SDK for daimon MCP services.
+Author: processd contributors
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: fastmcp<4,>=3.1.1
+Requires-Dist: httpx<1,>=0.28
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio<1,>=0.24; extra == 'dev'
+Requires-Dist: pytest<9,>=8.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# daimon-sdk
+
+Typed async Python SDK for `processd-mcp`.
+
+`daimon-sdk` wraps the raw MCP tool surface exposed by `processd-mcp` and presents it as grouped Python APIs such as `client.files.read()` and `client.exec.start_session()`. The SDK keeps `processd-standalone` as the contract source of truth and focuses on:
+
+- connection and token wiring
+- typed request/response handling
+- structured tool error mapping
+- interactive session helpers
+- compatibility tests against a real `processd-mcp` binary
+
+## Install
+
+```bash
+pip install daimon-sdk
+```
+
+For local development:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+import asyncio
+
+from daimon_sdk import DaimonClient
+
+
+async def main() -> None:
+    async with DaimonClient("http://127.0.0.1:8080/mcp") as client:
+        runtime = await client.runtime.get_context()
+        print(runtime.base_workdir)
+
+        result = await client.files.glob("**/*.rs", path=runtime.base_workdir)
+        print(result.filenames[:5])
+
+        bash = await client.exec.bash("printf 'hello from processd\\n'")
+        print(bash.stdout)
+
+
+asyncio.run(main())
+```
+
+## Raw MCP vs SDK
+
+Raw MCP:
+
+```python
+payload = await mcp_client.call_tool("Read", {"file_path": "/tmp/demo.txt"})
+```
+
+SDK:
+
+```python
+read = await client.files.read("/tmp/demo.txt")
+print(read.file.content)
+```
+
+## API Overview
+
+- `DaimonClient(base_url, access_token=None, timeout_s=30.0)`
+- `await client.connect()` / `await client.close()`
+- `async with DaimonClient(...) as client`
+- `client.runtime.get_context()`
+- `client.files.read() / write() / edit() / glob() / grep()`
+- `client.exec.bash() / start_session()`
+- `SessionHandle.write() / poll() / wait_for_exit() / close()`
+- `client.web.fetch()`
+- `client.raw.call_tool()`
+
+## Local Testing
+
+The SDK compatibility tests expect a sibling checkout of `processd-standalone`:
+
+```text
+e2b-project/
+  processd-standalone/
+  processd-sdk/
+```
+
+Run tests with an environment that already has the dev dependencies installed:
+
+```bash
+PYTHONPATH=src python -m pytest -q
+```
+
+The E2E suite builds and launches `../processd-standalone/target/debug/processd-mcp`.
+
+## Release
+
+Releases are published from GitHub Actions when a tag matching `v*` is pushed.
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+The tag version must match `pyproject.toml`'s project version.

daimon_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+daimon_sdk/__init__.py,sha256=Roky3wQ-p6AEOd6lq_4riuzoXmKnTILXMrsu1oT4SM4,650
+daimon_sdk/_transport.py,sha256=U9vSTGmiWSbF829Wsw3kFIjaM1Q0Kt5DNhCznjopQd8,5064
+daimon_sdk/client.py,sha256=mf0Ris81hcnTcfRTVNKEx_0jRgtJBu8SvWyEOr-9_vM,14450
+daimon_sdk/exceptions.py,sha256=YnRwjuXJywsHmRhQVRAiYJ_0Wa0OL1OGXcdM1lWsDbQ,695
+daimon_sdk/models.py,sha256=d1Vm7sxokeurX2vaw2F2rEWnyA5ojFzanjli0cdn3wU,5786
+daimon_sdk-0.1.0.dist-info/METADATA,sha256=dgZXZnLb-Tbb2sRNH09QcKD84YCfps4f83LNM1ynhj8,2744
+daimon_sdk-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+daimon_sdk-0.1.0.dist-info/RECORD,,

daimon_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any