AbstractRuntime 0.10.2__tar.gz → 0.10.4__tar.gz

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/CHANGELOG.md

@@ -5,6 +5,35 @@ All notable changes to AbstractRuntime will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.10.4] - 2026-10-18
+
+### Fixed
+
+- An image, video or voice spec whose provider is an endpoint profile (`endpoint:<id>`) keeps that provider
+  all the way to the media plugin. The `LLM_CALL` handler resolved the first output spec's endpoint as if it
+  were the call's text provider: it rewrote the spec to the bare provider family and put the endpoint's URL
+  and key into text-client routing params that the media path never reads, so an image generation routed to
+  a gateway endpoint profile (the web console's sandbox, an image route set to an OpenAI-compatible relay
+  serving `gpt-image-2`) reached AbstractVision as a keyless `openai-compatible` request with no base URL
+  and failed with "Missing vision_base_url / OPENAI_BASE_URL" -- in the one-shot media subprocess, since
+  the spec no longer said `endpoint:`. Only the call's own `provider` (`_provider`) is resolved now; the
+  spec's endpoint is resolved by the media plugin through the host's resolver, in process. The pooled
+  client's media host (the client every media-only call runs on) now carries the host's endpoint-profile
+  resolver, whether it is built before or after `set_provider_endpoint_profile_resolver`. Affects every
+  host that attaches an endpoint-profile resolver (AbstractGateway). Tests:
+  `tests/test_endpoint_profile_media_specs_keep_provider.py`.
+
+## [0.10.3] - 2026-10-18
+
+### Fixed
+
+- Image and video specs whose provider is an endpoint profile (`endpoint:<id>`) run in process instead of in
+  the one-shot local media subprocess. The subprocess isolates local pipelines and has no host
+  endpoint-profile resolver, so a gateway profile (for example an OpenAI-compatible relay serving
+  `gpt-image-2` selected on the gateway's image route) could not be resolved there; in process,
+  AbstractVision resolves it through the resolver the host attached to the client. Tests:
+  `tests/test_endpoint_profile_media_in_process.py`.
+
 ## [0.10.2] - 2026-10-16
 
 ### Changed

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.10.2
+Version: 0.10.4
 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

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/docs/api.md

@@ -355,6 +355,8 @@ Multimodal support:
 - with the pooled local client (`MultiLocalAbstractCoreLLMClient`), a request whose outputs are all non-text (image, video, voice, music, transcription) and that carries no tools never builds the text client: it runs on AbstractCore's capability host (`CapabilityHostProvider`, no text model), and so does streaming TTS. A text default that cannot be built (an engine not installed) therefore never blocks speech or image generation
 - media-only normalized results expose `runtime_provider` / `runtime_model` separately from `media_provider` / `media_model`
 - local image/video generation runs in a one-shot subprocess (`execution_mode="local_one_shot_subprocess"`) unless every requested media model is resident (explicitly loaded with `load_model_residency`), in which case it runs in-process on the loaded pipeline (`execution_mode="resident_in_process"`, `resident_load_ids`)
+- a media spec whose `provider` is an endpoint profile (`endpoint:<id>`) never uses the one-shot subprocess: it is an HTTP call to that endpoint, and the host's endpoint-profile resolver (`set_provider_endpoint_profile_resolver`) exists only in this process
+- the `LLM_CALL` handler resolves only the call's own `provider` (`endpoint:<id>` on the effect payload) into Core routing params (`_provider`, `base_url`, `provider_api_key`); an endpoint profile named on an output spec stays on the spec, and the media plugin resolves it through the resolver the host attached to the client. The pooled client attaches that resolver to its media host too
 - optional local media residency failures complete with `status_hint="warning"` and `degraded=true`; local media warmup that no capability plugin can serve (`image_generation`, `image_upscale`, `video_generation`, `text_to_video`, `image_to_video`, `tts`, `stt`, `music_generation`) reports `requires_long_lived_server=true`, and image/video tasks also report `execution_mode="local_one_shot_subprocess"`
 - Gateway/hosts remain responsible for explicit Core server URLs, Core server auth headers, provider/model defaults, selected local-inference profiles, and translation of Gateway-owned env/config into explicit Runtime inputs; Runtime persists only JSON-safe routing metadata and artifact refs
 

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/llms-full.txt

@@ -1225,6 +1225,8 @@ Multimodal support:
 - with the pooled local client (`MultiLocalAbstractCoreLLMClient`), a request whose outputs are all non-text (image, video, voice, music, transcription) and that carries no tools never builds the text client: it runs on AbstractCore's capability host (`CapabilityHostProvider`, no text model), and so does streaming TTS. A text default that cannot be built (an engine not installed) therefore never blocks speech or image generation
 - media-only normalized results expose `runtime_provider` / `runtime_model` separately from `media_provider` / `media_model`
 - local image/video generation runs in a one-shot subprocess (`execution_mode="local_one_shot_subprocess"`) unless every requested media model is resident (explicitly loaded with `load_model_residency`), in which case it runs in-process on the loaded pipeline (`execution_mode="resident_in_process"`, `resident_load_ids`)
+- a media spec whose `provider` is an endpoint profile (`endpoint:<id>`) never uses the one-shot subprocess: it is an HTTP call to that endpoint, and the host's endpoint-profile resolver (`set_provider_endpoint_profile_resolver`) exists only in this process
+- the `LLM_CALL` handler resolves only the call's own `provider` (`endpoint:<id>` on the effect payload) into Core routing params (`_provider`, `base_url`, `provider_api_key`); an endpoint profile named on an output spec stays on the spec, and the media plugin resolves it through the resolver the host attached to the client. The pooled client attaches that resolver to its media host too
 - optional local media residency failures complete with `status_hint="warning"` and `degraded=true`; local media warmup that no capability plugin can serve (`image_generation`, `image_upscale`, `video_generation`, `text_to_video`, `image_to_video`, `tts`, `stt`, `music_generation`) reports `requires_long_lived_server=true`, and image/video tasks also report `execution_mode="local_one_shot_subprocess"`
 - Gateway/hosts remain responsible for explicit Core server URLs, Core server auth headers, provider/model defaults, selected local-inference profiles, and translation of Gateway-owned env/config into explicit Runtime inputs; Runtime persists only JSON-safe routing metadata and artifact refs
 

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/pyproject.toml

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

abstractruntime-0.10.4/release-notes.md

@@ -0,0 +1,15 @@
+### Fixed
+
+- An image, video or voice spec whose provider is an endpoint profile (`endpoint:<id>`) keeps that provider
+  all the way to the media plugin. The `LLM_CALL` handler resolved the first output spec's endpoint as if it
+  were the call's text provider: it rewrote the spec to the bare provider family and put the endpoint's URL
+  and key into text-client routing params that the media path never reads, so an image generation routed to
+  a gateway endpoint profile (the web console's sandbox, an image route set to an OpenAI-compatible relay
+  serving `gpt-image-2`) reached AbstractVision as a keyless `openai-compatible` request with no base URL
+  and failed with "Missing vision_base_url / OPENAI_BASE_URL" -- in the one-shot media subprocess, since
+  the spec no longer said `endpoint:`. Only the call's own `provider` (`_provider`) is resolved now; the
+  spec's endpoint is resolved by the media plugin through the host's resolver, in process. The pooled
+  client's media host (the client every media-only call runs on) now carries the host's endpoint-profile
+  resolver, whether it is built before or after `set_provider_endpoint_profile_resolver`. Affects every
+  host that attaches an endpoint-profile resolver (AbstractGateway). Tests:
+  `tests/test_endpoint_profile_media_specs_keep_provider.py`.

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/src/abstractruntime/integrations/abstractcore/effect_handlers.py

@@ -228,56 +228,28 @@ def _observability_params(params: Dict[str, Any]) -> Dict[str, Any]:
 _MISSING = object()
 
 
-def _first_output_provider(value: Any) -> Optional[str]:
-    if isinstance(value, dict):
-        provider = value.get("provider")
-        if isinstance(provider, str) and provider.strip():
-            return provider.strip()
-        specs = value.get("specs")
-        if isinstance(specs, list):
-            for item in specs:
-                found = _first_output_provider(item)
-                if found:
-                    return found
-    elif isinstance(value, list):
-        for item in value:
-            found = _first_output_provider(item)
-            if found:
-                return found
-    return None
-
-
-def _replace_output_provider(value: Any, *, old_provider: str, new_provider: str) -> Any:
-    old_norm = str(old_provider or "").strip().lower()
-    if not old_norm or not isinstance(new_provider, str) or not new_provider.strip():
-        return value
-    if isinstance(value, dict):
-        out = dict(value)
-        provider = out.get("provider")
-        if isinstance(provider, str) and provider.strip().lower() == old_norm:
-            out["provider"] = new_provider.strip()
-        if isinstance(out.get("specs"), list):
-            out["specs"] = [_replace_output_provider(item, old_provider=old_provider, new_provider=new_provider) for item in out["specs"]]
-        return out
-    if isinstance(value, list):
-        return [_replace_output_provider(item, old_provider=old_provider, new_provider=new_provider) for item in value]
-    return value
-
-
 def _apply_provider_endpoint_profile_resolution(*, llm: AbstractCoreLLMClient, params: Dict[str, Any]) -> None:
-    """Resolve a host-provided virtual provider profile into Core routing params.
+    """Resolve the call's own `endpoint:<id>` text provider into Core routing params.
 
     Hosts can attach `resolve_provider_endpoint_profile(provider_id)` to the LLM
     client. Runtime keeps this as a generic optional hook so it does not import
     Gateway, and only the transient `params` dict receives the raw provider key.
+
+    Only `_provider` (the text route of THIS call) is resolved here. An output
+    spec that names an `endpoint:<id>` provider (an image, video or voice
+    generation through a named endpoint connection) keeps it: the media
+    plugins resolve the profile themselves through the resolver the host
+    attached to the client, and the runtime keeps such a spec in process
+    (`_is_subprocess_safe_image_specs`). Rewriting it to the bare provider
+    family used to lose the endpoint -- the spec reached the media backend as
+    a keyless `openai-compatible` request with no base URL, while the URL and
+    key sat in text-client kwargs the media path never reads.
     """
 
     resolver = getattr(llm, "resolve_provider_endpoint_profile", None)
     if not callable(resolver):
         return
     provider = params.get("_provider")
-    if not (isinstance(provider, str) and provider.strip()):
-        provider = _first_output_provider(params.get("output"))
     if not (isinstance(provider, str) and provider.strip()):
         return
     try:
@@ -292,8 +264,6 @@ def _apply_provider_endpoint_profile_resolution(*, llm: AbstractCoreLLMClient, p
         raise RuntimeError(f"Provider endpoint profile {provider!r} did not resolve to a provider family.")
 
     params["_provider"] = provider_family
-    if "output" in params:
-        params["output"] = _replace_output_provider(params.get("output"), old_provider=provider, new_provider=provider_family)
 
     base_url = resolved.get("base_url")
     if isinstance(base_url, str) and base_url.strip() and not str(params.get("base_url") or "").strip():

{abstractruntime-0.10.2 → abstractruntime-0.10.4}/src/abstractruntime/integrations/abstractcore/llm_client.py

@@ -2141,6 +2141,20 @@ def _decode_subprocess_media_payload(payload: Dict[str, Any]) -> Dict[str, Any]:
     return out
 
 
+def _spec_routes_to_endpoint_profile(spec: Any) -> bool:
+    """True when a media spec names an `endpoint:<id>` provider.
+
+    Such a spec is an HTTP call to a named endpoint connection, not a local
+    pipeline: the one-shot media subprocess has nothing to isolate for it, and
+    it cannot resolve the profile -- the host's endpoint-profile resolver
+    (`set_provider_endpoint_profile_resolver`) lives on THIS process's
+    clients, and a per-user gateway profile has no AbstractCore config row
+    the subprocess could read. So it runs in process, where AbstractVision
+    resolves the profile through the owning provider's resolver.
+    """
+    return isinstance(spec, dict) and str(spec.get("provider") or "").strip().lower().startswith("endpoint:")
+
+
 def _is_subprocess_safe_image_specs(specs: List[Dict[str, Any]], media: Optional[List[Any]]) -> bool:
     if not _env_flag_enabled("ABSTRACTRUNTIME_LOCAL_IMAGE_SUBPROCESS", default=True):
         return False
@@ -2148,7 +2162,7 @@ def _is_subprocess_safe_image_specs(specs: List[Dict[str, Any]], media: Optional
         return False
     normalized_media = list(media or [])
     for spec in specs:
-        if not isinstance(spec, dict):
+        if not isinstance(spec, dict) or _spec_routes_to_endpoint_profile(spec):
             return False
         modality = str(spec.get("modality") or "").strip().lower()
         task = str(spec.get("task") or "").strip().lower()
@@ -2202,6 +2216,8 @@ def _is_subprocess_safe_video_specs(specs: List[Dict[str, Any]], media: Optional
     if len(specs) != 1 or not isinstance(specs[0], dict):
         return False
     spec = specs[0]
+    if _spec_routes_to_endpoint_profile(spec):
+        return False
     modality = str(spec.get("modality") or "").strip().lower()
     task = str(spec.get("task") or "").strip().lower()
     if modality != "video":
@@ -10753,6 +10769,11 @@ class MultiLocalAbstractCoreLLMClient:
                     core_config_file=self._core_config_file,
                     capability_defaults=self._capability_defaults if explicit else None,
                 )
+            # A media spec naming an `endpoint:<id>` provider is resolved by the
+            # media plugin through the resolver on ITS owner -- this client.
+            resolver = getattr(self, "_provider_endpoint_profile_resolver", None)
+            if resolver is not None:
+                _attach_provider_endpoint_profile_resolver_to_client(client, resolver)
             self._media_host = client
             return client
 
@@ -10828,6 +10849,9 @@ class MultiLocalAbstractCoreLLMClient:
         default_client = getattr(self, "_default_client", None)
         if default_client is not None:
             _attach_provider_endpoint_profile_resolver_to_client(default_client, resolver)
+        media_host = self.__dict__.get("_media_host")
+        if media_host is not None:
+            _attach_provider_endpoint_profile_resolver_to_client(media_host, resolver)
         self._llm = getattr(default_client, "_llm", None)
 
     def get_provider_instance(self, *, provider: str, model: str) -> Any:

abstractruntime-0.10.4/tests/test_endpoint_profile_media_in_process.py

@@ -0,0 +1,45 @@
+"""Media specs routed to an `endpoint:<id>` profile run in process.
+
+The one-shot media subprocess isolates LOCAL pipelines; it has no host
+endpoint-profile resolver, so a gateway profile (e.g. an OpenAI-compatible
+relay serving `gpt-image-2`) could not be resolved there. Regression for the
+operator report of 2026-10-18.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from abstractruntime.integrations.abstractcore.llm_client import (
+    _is_subprocess_safe_image_specs,
+    _is_subprocess_safe_video_specs,
+    _spec_routes_to_endpoint_profile,
+)
+
+
+def test_endpoint_spec_detection() -> None:
+    assert _spec_routes_to_endpoint_profile({"provider": "endpoint:relay"}) is True
+    assert _spec_routes_to_endpoint_profile({"provider": "Endpoint:Relay"}) is True
+    assert _spec_routes_to_endpoint_profile({"provider": "huggingface"}) is False
+    assert _spec_routes_to_endpoint_profile({}) is False
+    assert _spec_routes_to_endpoint_profile(None) is False
+
+
+def test_endpoint_image_specs_skip_the_subprocess(tmp_path: Path) -> None:
+    source = tmp_path / "source.png"
+    source.write_bytes(b"png")
+    media = [{"file_path": str(source), "type": "image", "role": "source"}]
+
+    assert _is_subprocess_safe_image_specs([{"modality": "image", "task": "text_to_image", "provider": "huggingface"}], None) is True
+    assert _is_subprocess_safe_image_specs(
+        [{"modality": "image", "task": "text_to_image", "provider": "endpoint:relay", "model": "gpt-image-2"}], None
+    ) is False
+    assert _is_subprocess_safe_image_specs([{"modality": "image", "task": "image_edit", "provider": "huggingface"}], media) is True
+    assert _is_subprocess_safe_image_specs(
+        [{"modality": "image", "task": "image_edit", "provider": "endpoint:relay", "model": "gpt-image-2"}], media
+    ) is False
+
+
+def test_endpoint_video_spec_skips_the_subprocess() -> None:
+    assert _is_subprocess_safe_video_specs([{"modality": "video", "task": "text_to_video"}], None) is True
+    assert _is_subprocess_safe_video_specs([{"modality": "video", "task": "text_to_video", "provider": "endpoint:relay"}], None) is False

abstractruntime-0.10.4/tests/test_endpoint_profile_media_specs_keep_provider.py

@@ -0,0 +1,153 @@
+"""An output spec that names an `endpoint:<id>` provider keeps it.
+
+The LLM_CALL handler resolves the call's OWN text provider (`_provider`) into
+Core routing params. It used to fall back to the first output spec's provider
+and rewrite that spec to the bare provider family, moving the endpoint's URL
+and key into text-client kwargs the media path never reads: an image
+generation routed to a gateway endpoint profile (the web console's sandbox,
+the image route set to an OpenAI-compatible relay serving `gpt-image-2`)
+reached AbstractVision as a keyless `openai-compatible` request with no base
+URL and failed with "Missing vision_base_url / OPENAI_BASE_URL" -- in the
+one-shot media subprocess, since the spec no longer said `endpoint:`.
+Regression for the operator report of 2026-10-18.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from abstractruntime.core.models import Effect, EffectType, RunState
+from abstractruntime.integrations.abstractcore.effect_handlers import make_llm_call_handler
+from abstractruntime.storage.artifacts import InMemoryArtifactStore
+
+_PROFILE = {
+    "id": "airelays",
+    "virtual_provider": "endpoint:airelays",
+    "display_name": "airelays",
+    "provider": "openai-compatible",
+    "base_url": "http://127.0.0.1:18921/v1",
+    "api_key": "relay-secret-key",
+    "scope": "gateway",
+}
+
+
+class _ProfileResolvingLLM:
+    def __init__(self) -> None:
+        self.calls: list[dict[str, Any]] = []
+        self.resolved: list[str] = []
+
+    def resolve_provider_endpoint_profile(self, provider_id: str) -> dict[str, Any] | None:
+        self.resolved.append(provider_id)
+        return dict(_PROFILE) if provider_id == "endpoint:airelays" else None
+
+    def generate(
+        self,
+        *,
+        prompt: str,
+        messages: Optional[List[Dict[str, str]]] = None,
+        system_prompt: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        media: Optional[List[Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        self.calls.append({"prompt": prompt, "media": media, "params": dict(params or {})})
+        return {"content": "", "metadata": {}}
+
+
+def _image_effect(*, provider: Optional[str] = None) -> Effect:
+    payload: Dict[str, Any] = {
+        "prompt": "a red circle",
+        "output": {
+            "modality": "image",
+            "task": "image_generation",
+            "format": "png",
+            "provider": "endpoint:airelays",
+            "model": "gpt-image-2",
+        },
+    }
+    if provider:
+        payload["provider"] = provider
+    return Effect(type=EffectType.LLM_CALL, payload=payload, result_key="llm")
+
+
+def _run() -> RunState:
+    run = RunState.new(workflow_id="wf", entry_node="node-1", vars={})
+    run.current_node = "node-1"
+    return run
+
+
+def test_media_spec_endpoint_provider_reaches_the_client_untouched() -> None:
+    llm = _ProfileResolvingLLM()
+    handler = make_llm_call_handler(llm=llm, artifact_store=InMemoryArtifactStore())
+
+    outcome = handler(_run(), _image_effect(), None)
+
+    assert outcome.status == "completed"
+    params = llm.calls[-1]["params"]
+    assert params["output"]["provider"] == "endpoint:airelays"
+    assert params["output"]["model"] == "gpt-image-2"
+    # The endpoint is the SPEC's, not the call's text route: no text routing
+    # params are minted from it, and nothing is resolved on its behalf.
+    assert "_provider" not in params
+    assert "base_url" not in params
+    assert "provider_api_key" not in params
+    assert "_provider_endpoint_profile" not in params
+    assert llm.resolved == []
+
+
+def test_text_endpoint_provider_is_resolved_while_the_media_spec_keeps_its_own() -> None:
+    llm = _ProfileResolvingLLM()
+    handler = make_llm_call_handler(llm=llm, artifact_store=InMemoryArtifactStore())
+
+    outcome = handler(_run(), _image_effect(provider="endpoint:airelays"), None)
+
+    assert outcome.status == "completed"
+    params = llm.calls[-1]["params"]
+    assert params["_provider"] == "openai-compatible"
+    assert params["base_url"] == "http://127.0.0.1:18921/v1"
+    assert params["provider_api_key"] == "relay-secret-key"
+    assert params["_provider_endpoint_profile"]["virtual_provider"] == "endpoint:airelays"
+    assert params["output"]["provider"] == "endpoint:airelays"
+    assert llm.resolved == ["endpoint:airelays"]
+
+
+def test_media_host_client_carries_the_endpoint_profile_resolver(monkeypatch) -> None:
+    """The pooled client's media host serves every media-only call; the media
+    plugins resolve `endpoint:<id>` through the resolver on THAT client."""
+    from abstractruntime.integrations.abstractcore import llm_client as llm_client_mod
+
+    created: list[Any] = []
+
+    class FakeUnderlyingLLM:
+        pass
+
+    class FakeLocalClient:
+        def __init__(self, *, provider, model, llm_kwargs=None, **kwargs):
+            _ = provider, model, llm_kwargs, kwargs
+            self._llm = FakeUnderlyingLLM()
+            created.append(self)
+
+        def generate(self, *, prompt, messages=None, system_prompt=None, tools=None, media=None, params=None):
+            _ = prompt, messages, system_prompt, tools, media, params
+            return {"content": "ok"}
+
+        def get_model_capabilities(self, model_name=None):
+            _ = model_name
+            return {"max_tokens": 8192}
+
+    monkeypatch.setattr(llm_client_mod, "LocalAbstractCoreLLMClient", FakeLocalClient)
+    resolver = lambda provider_id: {"provider": "openai-compatible", "id": provider_id}  # noqa: E731
+
+    # Resolver set BEFORE the media host is built (the gateway's boot order).
+    client = llm_client_mod.MultiLocalAbstractCoreLLMClient(provider="lmstudio", model="local-model")
+    client.set_provider_endpoint_profile_resolver(resolver)
+    media_host = client._media_host_client()
+    assert getattr(media_host, "resolve_provider_endpoint_profile") is resolver
+    assert getattr(media_host._llm, "resolve_provider_endpoint_profile") is resolver
+
+    # Resolver (re)set AFTER the media host exists (a profile refresh).
+    later = lambda provider_id: {"provider": "openai", "id": provider_id}  # noqa: E731
+    client.set_provider_endpoint_profile_resolver(later)
+    assert client._media_host_client() is media_host
+    assert getattr(media_host, "resolve_provider_endpoint_profile") is later
+    assert getattr(media_host._llm, "resolve_provider_endpoint_profile") is later

abstractruntime-0.10.2/release-notes.md

@@ -1,19 +0,0 @@
-### Changed
-
-- **Code nodes can import Python's standard library.** In the `sandbox` permission mode, `import json`, `re`,
-  `datetime`, `math`, `collections`, `itertools`, `statistics`, `textwrap`, `hashlib`, `urllib.parse`… now
-  work, at the top of the code and inside functions, in both the RestrictedPython lane and the fallback lane, and
-  inside the function bodies of flow function libraries. The sandbox still refuses third-party packages, private
-  (`_`-prefixed) modules, and the standard-library modules that reach the machine or go around the sandbox's own
-  checks: processes and the operating system (`os`, `subprocess`, `threading`, `signal`, `ctypes`, `platform`…), files (`io`,
-  `pathlib`, `shutil`, `tempfile`, `glob`, `sqlite3`, `logging`, and the parsers that read a file by path: `xml`,
-  `configparser`, `argparse`…), the network (`socket`, `http`, `urllib.request`, `smtplib`…), code loading or
-  interpreter internals (`sys`, `importlib`, `pickle`, `types`, `inspect`…) and attribute access by name,
-  evaluated annotations or frames (`operator`, `typing`, `functools`, `traceback`). A refusal names the module
-  and the reason; `from x import *`, relative imports and the `__import__` call stay refused.
-- **A Code node's return value must be JSON data.** `transform` returning a module, a function, a set, bytes or
-  any other value JSON cannot carry now fails with a sandbox error naming the value and where it sits
-  (`transform returned a value that cannot be sent as JSON: module 'time' at output[2]`), in every permission
-  mode, instead of a serializer crash later in the gateway's simulate reply or the run's persisted state. `full_access` (host policy) imports anything, as before.
-  The rule is applied twice: at compile time by `validate_code`, and at run time by the `__import__` bound into
-  the sandbox builtins. `get_code_execution_policy()` now lists `imports.denied_modules` for thin clients.