AbstractRuntime 0.4.18__tar.gz → 0.4.19__tar.gz

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.19] - 2026-05-21
+
+### Added
+- Runtime now ships the missed standalone email comms wrapper/export layer for host-local operator surfaces:
+  - `abstractruntime.integrations.abstractcore.comms_facade`
+  - package-level email helper exports from `abstractruntime.integrations.abstractcore`
+
+### Changed
+- Host-facade email helpers now delegate through Runtime's own comms facade instead of importing `abstractcore.tools.comms_tools` directly in the facade method body.
+- Runtime docs and AI-readable `llms.txt` / `llms-full.txt` now describe the standalone email comms facade/export layer alongside the existing host facade, Telegram wrappers, and durable run-owned comms sends.
+
 ## [0.4.18] - 2026-05-21
 
 ### Added
@@ -478,7 +489,8 @@ AbstractRuntime is the durable execution substrate designed to pair with Abstrac
 
 Initial development version with basic proof-of-concept features.
 
-[Unreleased]: https://github.com/lpalbou/abstractruntime/compare/v0.4.18...HEAD
+[Unreleased]: https://github.com/lpalbou/abstractruntime/compare/v0.4.19...HEAD
+[0.4.19]: https://github.com/lpalbou/abstractruntime/compare/v0.4.18...v0.4.19
 [0.4.18]: https://github.com/lpalbou/abstractruntime/compare/v0.4.17...v0.4.18
 [0.4.17]: https://github.com/lpalbou/abstractruntime/compare/v0.4.16...v0.4.17
 [0.4.16]: https://github.com/lpalbou/abstractruntime/compare/v0.4.15...v0.4.16

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AbstractRuntime
-Version: 0.4.18
+Version: 0.4.19
 Summary: AbstractRuntime: a durable graph runner designed to pair with AbstractCore.
 Project-URL: AbstractCore (website), https://www.abstractcore.ai/
 Project-URL: AbstractRuntime (GitHub), https://github.com/lpalbou/abstractruntime
@@ -81,7 +81,7 @@ Description-Content-Type: text/markdown
 
 It is designed for long-running workflows that must survive restarts and explicitly model blocking (human input, timers, external events, subworkflows) without keeping Python stacks alive.
 
-**Version:** 0.4.18 • **Python:** 3.10+
+**Version:** 0.4.19 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
@@ -169,7 +169,7 @@ state = rt.resume(
 assert state.status.value == "completed"
 ```
 
-## What’s included (v0.4.18)
+## What’s included (v0.4.19)
 
 Kernel (dependency-light):
 - workflow graphs: `WorkflowSpec` (`src/abstractruntime/core/spec.py`)
@@ -194,7 +194,7 @@ Drivers + distribution:
 
 Optional integrations:
 - AbstractCore (LLM + tools, `MODEL_RESIDENCY`, public discovery/host/run facades, cached sessions, durable bloc prompt-cache controls, bindings, lifecycle operations, generated image/voice/music outputs, host email helpers, Telegram host wrappers, and tool approval waits): `docs/integrations/abstractcore.md`
-- For outbound comms, use the durable run facade when the send belongs to a run: `get_abstractcore_run_facade(...).send_email(...)` / `send_telegram_message(...)`. If that child run pauses for approval or passthrough execution, resume it through `resume_tool_calls(...)`. Direct host-facade send helpers remain host-local and nondurable.
+- For outbound comms, use the durable run facade when the send belongs to a run: `get_abstractcore_run_facade(...).send_email(...)` / `send_telegram_message(...)`. If that child run pauses for approval or passthrough execution, resume it through `resume_tool_calls(...)`. Direct host-facade send helpers and the standalone email comms facade remain host-local and nondurable.
 - AbstractMemory TripleStore integration for `MEMORY_KG_*` effects. Runtime
   depends on the light AbstractMemory contract; hosts choose storage backends
   such as LanceDB, SQLite, or in-memory stores.

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/README.md

@@ -4,7 +4,7 @@
 
 It is designed for long-running workflows that must survive restarts and explicitly model blocking (human input, timers, external events, subworkflows) without keeping Python stacks alive.
 
-**Version:** 0.4.18 • **Python:** 3.10+
+**Version:** 0.4.19 • **Python:** 3.10+
 
 **Status:** pre-1.0 (API may evolve). For production use, pin versions and follow `CHANGELOG.md`.
 
@@ -92,7 +92,7 @@ state = rt.resume(
 assert state.status.value == "completed"
 ```
 
-## What’s included (v0.4.18)
+## What’s included (v0.4.19)
 
 Kernel (dependency-light):
 - workflow graphs: `WorkflowSpec` (`src/abstractruntime/core/spec.py`)
@@ -117,7 +117,7 @@ Drivers + distribution:
 
 Optional integrations:
 - AbstractCore (LLM + tools, `MODEL_RESIDENCY`, public discovery/host/run facades, cached sessions, durable bloc prompt-cache controls, bindings, lifecycle operations, generated image/voice/music outputs, host email helpers, Telegram host wrappers, and tool approval waits): `docs/integrations/abstractcore.md`
-- For outbound comms, use the durable run facade when the send belongs to a run: `get_abstractcore_run_facade(...).send_email(...)` / `send_telegram_message(...)`. If that child run pauses for approval or passthrough execution, resume it through `resume_tool_calls(...)`. Direct host-facade send helpers remain host-local and nondurable.
+- For outbound comms, use the durable run facade when the send belongs to a run: `get_abstractcore_run_facade(...).send_email(...)` / `send_telegram_message(...)`. If that child run pauses for approval or passthrough execution, resume it through `resume_tool_calls(...)`. Direct host-facade send helpers and the standalone email comms facade remain host-local and nondurable.
 - AbstractMemory TripleStore integration for `MEMORY_KG_*` effects. Runtime
   depends on the light AbstractMemory contract; hosts choose storage backends
   such as LanceDB, SQLite, or in-memory stores.

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/docs/api.md

@@ -184,13 +184,14 @@ Entry points:
 - `create_local_runtime(...)`, `create_remote_runtime(...)`, `create_hybrid_runtime(...)` (`src/abstractruntime/integrations/abstractcore/factory.py`)
 - public discovery facade: `AbstractCoreDiscoveryFacade`, `get_abstractcore_discovery_facade(...)` (`src/abstractruntime/integrations/abstractcore/discovery_facade.py`)
 - public host facade: `AbstractCoreHostFacade`, `get_abstractcore_host_facade(...)` (`src/abstractruntime/integrations/abstractcore/host_facade.py`)
+- public email comms wrappers: `list_email_accounts(...)`, `list_emails(...)`, `read_email(...)`, `send_email(...)` (`src/abstractruntime/integrations/abstractcore/comms_facade.py`)
 - public Telegram host wrappers: `TelegramTdlibNotAvailable`, `bootstrap_telegram_auth_from_env(...)`, `get_global_telegram_client(...)`, `stop_global_telegram_client()`, `send_telegram_message(...)` (`src/abstractruntime/integrations/abstractcore/telegram_facade.py`)
 - public durable run facade: `AbstractCoreRunFacade`, `get_abstractcore_run_facade(...)` (`src/abstractruntime/integrations/abstractcore/run_facade.py`)
 - effect handler wiring: `build_effect_handlers(...)` (`src/abstractruntime/integrations/abstractcore/effect_handlers.py`)
 - tool executors: `MappingToolExecutor`, `AbstractCoreToolExecutor`, `PassthroughToolExecutor`, `ApprovalToolExecutor`, `ToolApprovalPolicy` (`src/abstractruntime/integrations/abstractcore/tool_executor.py`)
 - discovery-facade delegation is implemented by the configured AbstractCore LLM clients in `src/abstractruntime/integrations/abstractcore/llm_client.py` (`list_providers`, `list_provider_models`, `get_voice_catalog`, `list_tts_models`, `list_stt_models`, `list_music_providers`, `list_music_models`, `list_vision_provider_models`, `list_cached_vision_models`)
 - host-facade client delegation is implemented by the configured AbstractCore LLM clients in `src/abstractruntime/integrations/abstractcore/llm_client.py` (`get_prompt_cache_capabilities`, `get_prompt_cache_stats`, `prompt_cache_set`, `prompt_cache_update`, `prompt_cache_fork`, `prompt_cache_clear`, `prompt_cache_prepare_modules`, `upsert_text_bloc`, `get_bloc_record`, `list_blocs`, `get_bloc_kv_manifest`, `ensure_bloc_kv_artifact`, `load_bloc_kv_artifact`, `list_bloc_kv_artifacts`, `delete_bloc_kv_artifact`, `prune_bloc_kv_artifacts`, `delete_bloc`, `list_model_residency`, `load_model_residency`, `unload_model_residency`)
-- host-facade email helpers remain host-local wrappers over AbstractCore's public comms helpers (`list_email_accounts`, `list_emails`, `read_email`, `send_email`)
+- host-facade email helpers delegate to Runtime's host-local comms facade/export layer (`list_email_accounts`, `list_emails`, `read_email`, `send_email`)
 - run-facade helpers create and resume durable child runs for existing runs (`execute_llm_call`, `execute_tool_calls`, `resume_tool_calls`, `generate_image`, `generate_voice`, `generate_music`, `transcribe_audio`, `send_email`, `send_telegram_message`)
 
 `LLM_CALL` payloads are JSON-safe effect payloads. Common fields:

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/docs/architecture.md

@@ -1,7 +1,7 @@
 # AbstractRuntime — Architecture
 
 > Updated: 2026-05-21
-> Version: 0.4.18
+> Version: 0.4.19
 > Scope: this describes **what is implemented in this repository**.
 
 AbstractRuntime is a **durable workflow runtime**: it executes workflow graphs as a persisted state machine with explicit waits (user, time, events, jobs, subworkflows). A run can pause for hours/days and resume **without** keeping Python stacks/coroutines alive.

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/docs/faq.md

@@ -169,6 +169,10 @@ No. For the remaining host/operator paths, use Runtime's public wrappers instead
 - `...list_emails(...)`
 - `...read_email(...)`
 - `...send_email(...)`
+- `abstractruntime.integrations.abstractcore.list_email_accounts(...)`
+- `...list_emails(...)`
+- `...read_email(...)`
+- `...send_email(...)`
 - `abstractruntime.integrations.abstractcore.telegram_facade.bootstrap_telegram_auth_from_env(...)`
 - `...get_global_telegram_client(...)`
 - `...stop_global_telegram_client()`

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/docs/integrations/abstractcore.md

@@ -493,6 +493,11 @@ email and Telegram:
   - `list_emails(...)`
   - `read_email(...)`
   - `send_email(...)`
+- `abstractruntime.integrations.abstractcore.comms_facade` also exposes:
+  - `list_email_accounts(...)`
+  - `list_emails(...)`
+  - `read_email(...)`
+  - `send_email(...)`
 - `abstractruntime.integrations.abstractcore.telegram_facade` exposes:
   - `TelegramTdlibNotAvailable`
   - `bootstrap_telegram_auth_from_env(...)`
@@ -504,6 +509,9 @@ Contract notes:
 
 - These are **host-local** wrappers over current public AbstractCore tool
   modules. They do not proxy through the remote AbstractCore server.
+- The host facade email methods and the standalone `comms_facade` functions use
+  the same Runtime-owned email wrapper layer; choose whichever is more natural
+  for the host surface you are building.
 - They are intentionally **nondurable**. They do not write Runtime run history
   on their own.
 - Direct `send_email(...)` on the host facade and direct

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/docs/tools-comms.md

@@ -48,7 +48,7 @@ Notes:
 - In untrusted deployments, prefer passthrough tools so a host/worker boundary approves and executes tool calls (`PassthroughToolExecutor` in `src/abstractruntime/integrations/abstractcore/tool_executor.py`).
 - For local bridge-owned delivery flows, `ApprovalToolExecutor` can auto-run the Telegram send tools while requiring approval for email, WhatsApp, unknown tools, and write/command-style tools by default.
 - Separate from the durable `TOOL_CALLS` path, Runtime also exposes **host wrappers** for operator-owned email and Telegram surfaces:
-  - email helpers on `get_abstractcore_host_facade(runtime)`
+  - email helpers on `get_abstractcore_host_facade(runtime)` and `abstractruntime.integrations.abstractcore.comms_facade`
   - Telegram lifecycle/send wrappers in `abstractruntime.integrations.abstractcore.telegram_facade`
   - read/bootstrap helpers stay host-local and do not create run history by themselves
   - if an outbound send belongs to a run, prefer the durable run facade:

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/llms-full.txt

@@ -10,7 +10,7 @@ This file is an **agent-oriented build guide** for the AbstractRuntime *library*
 
 Quick facts:
 - Python: 3.10+ (`pyproject.toml`)
-- Version: 0.4.18
+- Version: 0.4.19
 - Ecosystem: [AbstractFramework](https://github.com/lpalbou/AbstractFramework) umbrella; pairs with [AbstractCore](https://github.com/lpalbou/abstractcore)
 - Public export surface (source of truth): `src/abstractruntime/__init__.py`
 - Optional AbstractCore baseline: `abstractruntime[abstractcore]` installs `abstractcore>=2.13.24`
@@ -222,7 +222,7 @@ Notes:
 - Use `ApprovalToolExecutor(delegate=..., policy=ToolApprovalPolicy())` when a local host should auto-run safe tools but pause for user approval before write/command/unknown tools.
 - Remote `params.api_key` and `params.provider_api_key` are compatibility inputs; runtime converts them to `X-AbstractCore-Provider-API-Key` headers for current AbstractCore servers.
 - Gateway/hosts choose Core server URLs, Core server auth headers, provider/model defaults, tool executors, artifact stores, and any Gateway env/config translation before Runtime sees the call.
-- Hosts should bind `get_abstractcore_host_facade(rt)` for prompt-cache, durable bloc/KV, model-residency, and host-local email helper operations instead of reaching through the private `_abstractcore_llm_client` attachment directly.
+- Hosts should bind `get_abstractcore_host_facade(rt)` for prompt-cache, durable bloc/KV, and model-residency control operations, and use the Runtime-owned email wrapper layer (`get_abstractcore_host_facade(rt)` or `abstractruntime.integrations.abstractcore.comms_facade`) for host-local email helper operations instead of importing `abstractcore.tools.comms_tools` directly.
 - Hosts should use `abstractruntime.integrations.abstractcore.telegram_facade` for Telegram TDLib bootstrap/global-client/send helpers instead of importing `abstractcore.tools.telegram_tdlib` or `abstractcore.tools.telegram_tools` directly. These wrappers remain host-local and do not proxy through a remote Core server.
 - If an outbound email or Telegram send belongs to a run, hosts should prefer `get_abstractcore_run_facade(rt).send_email(...)` or `send_telegram_message(...)`. Those are durable `TOOL_CALLS` child runs: Runtime records the request and outcome, and replay should reuse the recorded result instead of resending the message. If the child run waits for approval or passthrough host execution, resume it through the same public boundary with `resume_tool_calls(...)`.
 - Use `pip install "abstractruntime[multimodal]"` for common AbstractCore media, vision, voice, audio, and music dependencies.

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/llms.txt

@@ -3,7 +3,7 @@
 > Durable workflow runtime (interrupt → checkpoint → resume) with an append-only execution ledger.
 
 - Python: 3.10+ (see `pyproject.toml`)
-- Version: 0.4.18
+- Version: 0.4.19
 - Ecosystem: [AbstractFramework](https://github.com/lpalbou/AbstractFramework) umbrella, integrates with [AbstractCore](https://github.com/lpalbou/abstractcore)
 - Hard invariant: `RunState.vars` must be JSON-serializable (`src/abstractruntime/core/models.py`)
 - Current AbstractCore baseline: `abstractruntime[abstractcore]` installs `abstractcore>=2.13.24`
@@ -38,7 +38,7 @@
 - Prompt-cache tracks: use `LLM_CALL.params.prompt_cache_key`, `run.vars["_runtime"]["prompt_cache"]`, or `ABSTRACTRUNTIME_PROMPT_CACHE` for best-effort session reuse; use `LLM_CALL.params.prompt_cache_binding` for durable exact bloc-backed reuse. Local Runtime stores one content-addressed bloc per root plus provider/model-specific derived KV artifacts. Gateway prompt-cache env belongs in Gateway.
 - Durable bloc lifecycle: Runtime exposes `list_blocs(...)`, `list_bloc_kv_artifacts(...)`, `delete_bloc_kv_artifact(...)`, `prune_bloc_kv_artifacts(...)`, and `delete_bloc(...)`, with `dry_run`, `clear_loaded`, and `force` safety controls on the host facade.
 - Runtime-owned Core surfaces: `get_abstractcore_discovery_facade(...)`, `get_abstractcore_host_facade(...)`, and `get_abstractcore_run_facade(...)`
-- Host-local operator wrappers: the host facade now also wraps email helpers (`list_email_accounts`, `list_emails`, `read_email`, `send_email`), and `abstractruntime.integrations.abstractcore.telegram_facade` exposes Telegram bootstrap/global-client/send wrappers without requiring hosts to import AbstractCore directly.
+- Host-local operator wrappers: the host facade and `abstractruntime.integrations.abstractcore.comms_facade` expose email helpers (`list_email_accounts`, `list_emails`, `read_email`, `send_email`), and `abstractruntime.integrations.abstractcore.telegram_facade` exposes Telegram bootstrap/global-client/send wrappers without requiring hosts to import AbstractCore directly.
 - Durable outbound comms: when an email or Telegram send belongs to a run, use `get_abstractcore_run_facade(...).send_email(...)` or `send_telegram_message(...)` so Runtime records the request and outcome in a child run; replay should show the recorded result, not resend the message. If the child run waits for approval or passthrough execution, resume it through `resume_tool_calls(...)`.
 - [Artifacts](docs/api.md#artifacts-store-by-reference): JSON-safe refs for large payloads; generated images/audio/voice/music are stored here rather than embedded in `RunState.vars`
 - Remote multimodal guardrail: remote/hybrid media generation uses AbstractCore Server endpoints, does not inherit the chat model for media endpoints, rejects unsupported input media and non-file STT inputs instead of ignoring them, and redacts data URLs from persisted provider-request metadata

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.4.18"
+version = "0.4.19"
 description = "AbstractRuntime: a durable graph runner designed to pair with AbstractCore."
 readme = "README.md"
 requires-python = ">=3.10"

abstractruntime-0.4.19/release-notes.md

@@ -0,0 +1,8 @@
+### Added
+- Runtime now ships the missed standalone email comms wrapper/export layer for host-local operator surfaces:
+  - `abstractruntime.integrations.abstractcore.comms_facade`
+  - package-level email helper exports from `abstractruntime.integrations.abstractcore`
+
+### Changed
+- Host-facade email helpers now delegate through Runtime's own comms facade instead of importing `abstractcore.tools.comms_tools` directly in the facade method body.
+- Runtime docs and AI-readable `llms.txt` / `llms-full.txt` now describe the standalone email comms facade/export layer alongside the existing host facade, Telegram wrappers, and durable run-owned comms sends.

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/src/abstractruntime/integrations/abstractcore/__init__.py

@@ -8,7 +8,8 @@ Provides:
 - Effect handlers wiring
 - Convenience runtime factories for local/remote/hybrid modes
 - Public discovery facade for provider/media/catalog snapshot queries
-- Public host facade for prompt-cache, durable bloc/KV, model-residency, and host-local email control operations
+- Public host facade for prompt-cache, durable bloc/KV, and model-residency control operations
+- Public comms facade for host-local email helper operations
 - Public Telegram host wrappers for TDLib bootstrap/global-client/send parity
 - Public durable run facade for run-scoped AbstractCore LLM/tool child runs, including outbound comms sends
 - RuntimeConfig for limits and model capabilities
@@ -29,6 +30,12 @@ from .host_facade import (
     AbstractCoreHostFacade,
     get_abstractcore_host_facade,
 )
+from .comms_facade import (
+    list_email_accounts,
+    list_emails,
+    read_email,
+    send_email,
+)
 from .discovery_facade import (
     AbstractCoreDiscoveryFacade,
     get_abstractcore_discovery_facade,
@@ -86,6 +93,9 @@ __all__ = [
     "bootstrap_telegram_auth_from_env",
     "get_abstractcore_discovery_facade",
     "get_abstractcore_host_facade",
+    "list_email_accounts",
+    "list_emails",
+    "read_email",
     "get_global_telegram_client",
     "get_abstractcore_run_facade",
     "create_local_runtime",
@@ -93,6 +103,7 @@ __all__ = [
     "create_hybrid_runtime",
     "create_local_file_runtime",
     "create_remote_file_runtime",
+    "send_email",
     "send_telegram_message",
     "stop_global_telegram_client",
     "attach_global_event_bus_bridge",

abstractruntime-0.4.19/src/abstractruntime/integrations/abstractcore/comms_facade.py

@@ -0,0 +1,127 @@
+"""Runtime-owned email/comms wrapper surface for AbstractCore-backed hosts.
+
+Hosts should import this module instead of reaching into
+`abstractcore.tools.comms_tools` directly.
+
+Scope:
+- host-local email account listing
+- host-local email inbox listing/reading
+- host-local email sends
+
+Non-goals:
+- durable Runtime effect execution
+- run-scoped Runtime history
+- arbitrary browser-supplied SMTP/IMAP credentials
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional, Tuple
+
+
+def _load_comms_helpers() -> Tuple[Callable[..., Dict[str, Any]], Callable[..., Dict[str, Any]], Callable[..., Dict[str, Any]], Callable[..., Dict[str, Any]]]:
+    try:
+        from abstractcore.tools.comms_tools import list_email_accounts, list_emails, read_email, send_email
+    except Exception as exc:  # pragma: no cover - exercised through facade behavior tests
+        raise RuntimeError(
+            "Email helpers are unavailable. Install a Runtime environment with "
+            "AbstractCore's comms tools support."
+        ) from exc
+    return list_email_accounts, list_emails, read_email, send_email
+
+
+def _dependency_error(exc: Exception) -> Dict[str, Any]:
+    return {
+        "success": False,
+        "code": "dependency_missing",
+        "error": str(exc),
+    }
+
+
+def list_email_accounts() -> Dict[str, Any]:
+    try:
+        helper, _list_emails, _read_email, _send_email = _load_comms_helpers()
+    except Exception as exc:
+        return _dependency_error(exc)
+    return helper()
+
+
+def list_emails(
+    *,
+    account: Optional[str] = None,
+    mailbox: Optional[str] = None,
+    since: Optional[str] = None,
+    status: str = "all",
+    limit: int = 20,
+    timeout_s: float = 30.0,
+) -> Dict[str, Any]:
+    try:
+        _list_email_accounts, helper, _read_email, _send_email = _load_comms_helpers()
+    except Exception as exc:
+        return _dependency_error(exc)
+    return helper(
+        account=account,
+        mailbox=mailbox,
+        since=since,
+        status=status,
+        limit=limit,
+        timeout_s=timeout_s,
+    )
+
+
+def read_email(
+    *,
+    uid: str,
+    account: Optional[str] = None,
+    mailbox: Optional[str] = None,
+    timeout_s: float = 30.0,
+    max_body_chars: int = 20000,
+) -> Dict[str, Any]:
+    try:
+        _list_email_accounts, _list_emails, helper, _send_email = _load_comms_helpers()
+    except Exception as exc:
+        return _dependency_error(exc)
+    return helper(
+        uid=uid,
+        account=account,
+        mailbox=mailbox,
+        timeout_s=timeout_s,
+        max_body_chars=max_body_chars,
+    )
+
+
+def send_email(
+    to: Any,
+    subject: str,
+    *,
+    account: Optional[str] = None,
+    body_text: Optional[str] = None,
+    body_html: Optional[str] = None,
+    cc: Any = None,
+    bcc: Any = None,
+    timeout_s: float = 30.0,
+    headers: Optional[Dict[str, str]] = None,
+) -> Dict[str, Any]:
+    try:
+        _list_email_accounts, _list_emails, _read_email, helper = _load_comms_helpers()
+    except Exception as exc:
+        return _dependency_error(exc)
+    return helper(
+        to=to,
+        subject=subject,
+        account=account,
+        body_text=body_text,
+        body_html=body_html,
+        cc=cc,
+        bcc=bcc,
+        timeout_s=timeout_s,
+        headers=headers,
+    )
+
+
+__all__ = [
+    "list_email_accounts",
+    "list_emails",
+    "read_email",
+    "send_email",
+]

{abstractruntime-0.4.18 → abstractruntime-0.4.19}/src/abstractruntime/integrations/abstractcore/host_facade.py

@@ -657,7 +657,7 @@ class AbstractCoreHostFacade:
         )
 
     def list_email_accounts(self) -> Dict[str, Any]:
-        from abstractcore.tools.comms_tools import list_email_accounts
+        from .comms_facade import list_email_accounts
 
         return list_email_accounts()
 
@@ -671,7 +671,7 @@ class AbstractCoreHostFacade:
         limit: int = 20,
         timeout_s: float = 30.0,
     ) -> Dict[str, Any]:
-        from abstractcore.tools.comms_tools import list_emails
+        from .comms_facade import list_emails
 
         return list_emails(
             account=account,
@@ -691,7 +691,7 @@ class AbstractCoreHostFacade:
         timeout_s: float = 30.0,
         max_body_chars: int = 20000,
     ) -> Dict[str, Any]:
-        from abstractcore.tools.comms_tools import read_email
+        from .comms_facade import read_email
 
         return read_email(
             uid=uid,
@@ -720,8 +720,7 @@ class AbstractCoreHostFacade:
         `get_abstractcore_run_facade(runtime).send_email(...)` instead so
         Runtime authors the durable child-run truth.
         """
-
-        from abstractcore.tools.comms_tools import send_email
+        from .comms_facade import send_email
 
         return send_email(
             to=to,

abstractruntime-0.4.19/tests/test_abstractcore_comms_facade.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+import pytest
+
+from abstractruntime.integrations import abstractcore
+from abstractruntime.integrations.abstractcore import comms_facade
+from abstractruntime.integrations.abstractcore.comms_facade import (
+    list_email_accounts,
+    list_emails,
+    read_email,
+    send_email,
+)
+
+
+def test_public_comms_facade_exports_are_available() -> None:
+    assert abstractcore.list_email_accounts is list_email_accounts
+    assert abstractcore.list_emails is list_emails
+    assert abstractcore.read_email is read_email
+    assert abstractcore.send_email is send_email
+    assert "list_email_accounts" in abstractcore.__all__
+    assert "list_emails" in abstractcore.__all__
+    assert "read_email" in abstractcore.__all__
+    assert "send_email" in abstractcore.__all__
+    assert "list_email_accounts" in comms_facade.__all__
+    assert "list_emails" in comms_facade.__all__
+    assert "read_email" in comms_facade.__all__
+    assert "send_email" in comms_facade.__all__
+
+
+def test_list_email_accounts_delegates_to_core_helper(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        comms_facade,
+        "_load_comms_helpers",
+        lambda: (
+            lambda: {"success": True, "accounts": [{"account": "default"}]},
+            lambda **_kwargs: {},
+            lambda **_kwargs: {},
+            lambda **_kwargs: {},
+        ),
+    )
+
+    payload = list_email_accounts()
+
+    assert payload == {"success": True, "accounts": [{"account": "default"}]}
+
+
+def test_list_emails_delegates_to_core_helper(monkeypatch: pytest.MonkeyPatch) -> None:
+    recorded: Dict[str, Any] = {}
+
+    def _list_emails(**kwargs: Any) -> Dict[str, Any]:
+        recorded.update(kwargs)
+        return {"success": True, "messages": []}
+
+    monkeypatch.setattr(
+        comms_facade,
+        "_load_comms_helpers",
+        lambda: (
+            lambda: {},
+            _list_emails,
+            lambda **_kwargs: {},
+            lambda **_kwargs: {},
+        ),
+    )
+
+    payload = list_emails(account="default", mailbox="INBOX", since="7d", status="unread", limit=5, timeout_s=9)
+
+    assert payload == {"success": True, "messages": []}
+    assert recorded == {
+        "account": "default",
+        "mailbox": "INBOX",
+        "since": "7d",
+        "status": "unread",
+        "limit": 5,
+        "timeout_s": 9,
+    }
+
+
+def test_read_email_delegates_to_core_helper(monkeypatch: pytest.MonkeyPatch) -> None:
+    recorded: Dict[str, Any] = {}
+
+    def _read_email(**kwargs: Any) -> Dict[str, Any]:
+        recorded.update(kwargs)
+        return {"success": True, "uid": kwargs["uid"]}
+
+    monkeypatch.setattr(
+        comms_facade,
+        "_load_comms_helpers",
+        lambda: (
+            lambda: {},
+            lambda **_kwargs: {},
+            _read_email,
+            lambda **_kwargs: {},
+        ),
+    )
+
+    payload = read_email(uid="123", account="default", mailbox="INBOX", timeout_s=11, max_body_chars=5000)
+
+    assert payload == {"success": True, "uid": "123"}
+    assert recorded == {
+        "uid": "123",
+        "account": "default",
+        "mailbox": "INBOX",
+        "timeout_s": 11,
+        "max_body_chars": 5000,
+    }
+
+
+def test_send_email_delegates_to_core_helper(monkeypatch: pytest.MonkeyPatch) -> None:
+    recorded: Dict[str, Any] = {}
+
+    def _send_email(**kwargs: Any) -> Dict[str, Any]:
+        recorded.update(kwargs)
+        return {"success": True, "message_id": "<sent@example.com>"}
+
+    monkeypatch.setattr(
+        comms_facade,
+        "_load_comms_helpers",
+        lambda: (
+            lambda: {},
+            lambda **_kwargs: {},
+            lambda **_kwargs: {},
+            _send_email,
+        ),
+    )
+
+    payload = send_email(
+        ["a@example.com"],
+        "Hello",
+        account="ops",
+        body_text="Body",
+        cc=["c@example.com"],
+        bcc=["b@example.com"],
+        timeout_s=13,
+        headers={"X-Test": "1"},
+    )
+
+    assert payload == {"success": True, "message_id": "<sent@example.com>"}
+    assert recorded == {
+        "to": ["a@example.com"],
+        "subject": "Hello",
+        "account": "ops",
+        "body_text": "Body",
+        "body_html": None,
+        "cc": ["c@example.com"],
+        "bcc": ["b@example.com"],
+        "timeout_s": 13,
+        "headers": {"X-Test": "1"},
+    }
+
+
+def test_comms_helpers_return_structured_dependency_error(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        comms_facade,
+        "_load_comms_helpers",
+        lambda: (_ for _ in ()).throw(RuntimeError("email helper unavailable")),
+    )
+
+    assert list_email_accounts() == {
+        "success": False,
+        "code": "dependency_missing",
+        "error": "email helper unavailable",
+    }
+    assert list_emails() == {
+        "success": False,
+        "code": "dependency_missing",
+        "error": "email helper unavailable",
+    }
+    assert read_email(uid="123") == {
+        "success": False,
+        "code": "dependency_missing",
+        "error": "email helper unavailable",
+    }
+    assert send_email(["a@example.com"], "Hello") == {
+        "success": False,
+        "code": "dependency_missing",
+        "error": "email helper unavailable",
+    }

abstractruntime-0.4.18/release-notes.md

@@ -1,14 +0,0 @@
-### Added
-- Runtime now exposes the remaining Gateway-facing comms/Telegram package boundary through public Runtime wrappers:
-  - host-local email helpers on `get_abstractcore_host_facade(...)`
-  - host-local Telegram TDLib/bootstrap/global-client wrappers in `abstractruntime.integrations.abstractcore.telegram_facade`
-- Outbound email and Telegram sends can now execute as durable Runtime-authored child runs through `get_abstractcore_run_facade(...)`:
-  - `send_email(...)`
-  - `send_telegram_message(...)`
-  - `resume_tool_calls(...)` for approval-gated or passthrough tool waits
-
-### Changed
-- Runtime docs and AI-readable `llms.txt` / `llms-full.txt` now distinguish clearly between:
-  - host-local operator comms helpers
-  - durable run-owned outbound comms execution and replay semantics
-- Outbound comms replay now follows the Runtime-owned truth model: recorded send requests and outcomes are replayed as data, not re-executed as external sends.