Clients and transports

The control-plane clients and embedded transport boundary. Native Desktop HTTP uses a separate client described in the Desktop reference.

Choose your client · Reliability · All public exports

AsyncEdithHermes

AsyncEdithHermes(transport: AsyncTransport)

Canonical asynchronous EDITH Hermes client.

images instance-attribute

images = AsyncImagesAPI(transport)

control_plane instance-attribute

control_plane = AsyncControlPlaneAPI(transport)

runtime instance-attribute

runtime = AsyncRuntimeAPI(transport)

tools instance-attribute

tools = AsyncToolsAPI(transport)

gateway instance-attribute

gateway = AsyncGatewayAPI(transport)

inference instance-attribute

inference = AsyncInferenceAPI(transport)

providers instance-attribute

providers = AsyncProvidersAPI(transport)

cloud instance-attribute

cloud = _AsyncDynamicAPI(transport, 'cloud')

remote classmethod

remote(
    *,
    base_url: str,
    token: str | None = None,
    timeout: float = 30.0,
    max_retries: int = 2,
    http_client: AsyncClient | None = None,
) -> AsyncEdithHermes

embedded classmethod

embedded(*, driver: EmbeddedDriver) -> AsyncEdithHermes

local async classmethod

local(
    *, settings: Any = None, start_worker: bool = True
) -> AsyncEdithHermes

Run the real control plane in-process with selectable local providers.

Install edith-hermes-sdk[control-plane] first. The default settings use SQLite, anonymous local identity, and the external/process providers. Enable container in Settings.enabled_runtime_providers to create Docker-compatible containers.

aclose async

aclose() -> None

wait_for_image_build async

wait_for_image_build(
    build_id: str,
    *,
    timeout: float = 600.0,
    poll_interval: float = 1.0,
) -> dict[str, Any]

wait_for_provisioning_job async

wait_for_provisioning_job(
    job_id: str,
    *,
    timeout: float = 900.0,
    poll_interval: float = 1.0,
) -> dict[str, Any]

EdithHermes

EdithHermes(async_client: AsyncEdithHermes)

Synchronous facade. Streaming operations require AsyncEdithHermes.

images instance-attribute

images = _SyncNamespace(async_client.images, self._run)

control_plane instance-attribute

control_plane = _SyncNamespace(
    async_client.control_plane, self._run
)

runtime instance-attribute

runtime = _SyncNamespace(async_client.runtime, self._run)

tools instance-attribute

tools = _SyncNamespace(async_client.tools, self._run)

gateway instance-attribute

gateway = _SyncNamespace(async_client.gateway, self._run)

inference instance-attribute

inference = _SyncNamespace(
    async_client.inference, self._run
)

cloud instance-attribute

cloud = _SyncNamespace(async_client.cloud, self._run)

providers instance-attribute

providers = _SyncNamespace(
    async_client.providers, self._run
)

remote classmethod

remote(**kwargs: Any) -> EdithHermes

embedded classmethod

embedded(*, driver: EmbeddedDriver) -> EdithHermes

close

close() -> None

wait_for_image_build

wait_for_image_build(
    build_id: str, **kwargs: Any
) -> dict[str, Any]

wait_for_provisioning_job

wait_for_provisioning_job(
    job_id: str, **kwargs: Any
) -> dict[str, Any]

EmbeddedDriver

Bases: Protocol

Driver implemented by local Docker/Kubernetes or test environments.

invoke async

invoke(
    operation_id: str, arguments: Mapping[str, Any]
) -> Any

stream

stream(
    operation_id: str, arguments: Mapping[str, Any]
) -> AsyncIterator[dict[str, Any]]

aclose async

aclose() -> None