AbstractRuntime 0.10.4__tar.gz → 0.10.5__tar.gz

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

@@ -5,6 +5,18 @@ 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.5] - 2026-10-18
+
+### Changed
+
+- The pooled client wires every client it builds in one place (`_adopt_client`): the residency core, the
+  Core execution context, the host's endpoint-profile resolver and the pool-wide token callback reach the
+  text clients, the per-call override clients and the media host through the same path, and a setting
+  applied later reaches all of them through `_owned_clients`. No behaviour change. Tests:
+  `tests/test_endpoint_profile_media_end_to_end.py` (an image spec on an `endpoint:<id>` profile reaches
+  that endpoint through the `LLM_CALL` handler, the pooled client and AbstractCore's capability host, with
+  and without a text provider on the call).
+
 ## [0.10.4] - 2026-10-18
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.10.4
+Version: 0.10.5
 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.4 → abstractruntime-0.10.5}/docs/api.md

@@ -356,7 +356,7 @@ Multimodal support:
 - 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
+- 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. Every client the pooled client builds carries that resolver: the text clients, the per-call override clients and the media host that serves media-only calls
 - 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.4 → abstractruntime-0.10.5}/llms-full.txt

@@ -1226,7 +1226,7 @@ Multimodal support:
 - 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
+- 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. Every client the pooled client builds carries that resolver: the text clients, the per-call override clients and the media host that serves media-only calls
 - 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.4 → abstractruntime-0.10.5}/pyproject.toml

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

abstractruntime-0.10.5/release-notes.md

@@ -0,0 +1,9 @@
+### Changed
+
+- The pooled client wires every client it builds in one place (`_adopt_client`): the residency core, the
+  Core execution context, the host's endpoint-profile resolver and the pool-wide token callback reach the
+  text clients, the per-call override clients and the media host through the same path, and a setting
+  applied later reaches all of them through `_owned_clients`. No behaviour change. Tests:
+  `tests/test_endpoint_profile_media_end_to_end.py` (an image spec on an `endpoint:<id>` profile reaches
+  that endpoint through the `LLM_CALL` handler, the pooled client and AbstractCore's capability host, with
+  and without a text provider on the call).

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

@@ -10635,15 +10635,29 @@ class MultiLocalAbstractCoreLLMClient:
             if last_exc is not None:
                 raise last_exc
             raise TypeError("Failed to construct LocalAbstractCoreLLMClient")
-        # Media generation on the pooled client finds the models explicitly
-        # loaded into THIS pool's residency core (`_resident_capability_core_for`).
+        return self._adopt_client(client)
+
+    def _adopt_client(self, client: LocalAbstractCoreLLMClient) -> LocalAbstractCoreLLMClient:
+        """Wire a client this pool just built -- the ONE place for everything a
+        client inherits from its pool, so a client built on a new path cannot
+        miss part of it (the media host missed the resolver in 0.10.3):
+
+        - the residency core: media generation on the client finds the models
+          explicitly loaded into THIS pool (`_resident_capability_core_for`);
+        - the Core execution context (config store, capability defaults);
+        - the host's endpoint-profile resolver: the media plugins resolve an
+          `endpoint:<id>` spec through the resolver on their owner, this client;
+        - the pool-wide token callback.
+
+        A setting that arrives after construction reaches every client the
+        pool owns through its setter (`_owned_clients`)."""
         client._capability_residency_parent = weakref.ref(self)
-        if self._core_config_file or getattr(self, "_capability_defaults_explicit", bool(self._capability_defaults)):
+        explicit = getattr(self, "_capability_defaults_explicit", bool(self._capability_defaults))
+        if self._core_config_file or explicit:
             _attach_core_execution_context_to_client(
                 client,
                 core_config_file=self._core_config_file,
-                capability_defaults=self._capability_defaults
-                if getattr(self, "_capability_defaults_explicit", bool(self._capability_defaults)) else None,
+                capability_defaults=self._capability_defaults if explicit else None,
             )
         resolver = getattr(self, "_provider_endpoint_profile_resolver", None)
         if callable(resolver):
@@ -10653,19 +10667,21 @@ class MultiLocalAbstractCoreLLMClient:
             client.set_on_token(pool_on_token)
         return client
 
+    def _owned_clients(self) -> List[Any]:
+        """Every client this pool built and still serves: the pooled text
+        clients (`_pooled_clients`) and the media host. A pool-wide setting
+        applied after construction goes to all of them."""
+        media_host = self.__dict__.get("_media_host")
+        return [*self._pooled_clients(), *([media_host] if media_host is not None else [])]
+
     def set_on_token(self, callback: Optional[Any]) -> None:
         """Pool-wide token callback (code seat c1009 ask 3): registers on every
         pooled client — existing AND future (per-request provider/model
         overrides create clients lazily; without the fan-out they would
         silently not stream). Same contract as the per-client setter."""
         self._pool_on_token = callback if callable(callback) else None
-        for client in list(getattr(self, "_clients", {}).values()):
+        for client in self._owned_clients():
             client.set_on_token(self._pool_on_token)
-        for client in list(getattr(self, "_override_clients", {}).values()):
-            client.set_on_token(self._pool_on_token)
-        default_client = getattr(self, "_default_client", None)
-        if default_client is not None:
-            default_client.set_on_token(self._pool_on_token)
 
     def _get_client(
         self,
@@ -10762,20 +10778,8 @@ class MultiLocalAbstractCoreLLMClient:
                 capability_defaults=self._capability_defaults if explicit else None,
                 llm_factory=create_capability_host,
             )
-            client._capability_residency_parent = weakref.ref(self)
-            if self._core_config_file or explicit:
-                _attach_core_execution_context_to_client(
-                    client,
-                    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
+            self._media_host = self._adopt_client(client)
+            return self._media_host
 
     @contextmanager
     def _building_claim(self, key: Tuple[str, str]):
@@ -10842,17 +10846,9 @@ class MultiLocalAbstractCoreLLMClient:
     def set_provider_endpoint_profile_resolver(self, resolver: Any) -> None:
         self._provider_endpoint_profile_resolver = resolver
         _attach_provider_endpoint_profile_resolver_to_client(self, resolver)
-        for client in list(getattr(self, "_clients", {}).values()):
-            _attach_provider_endpoint_profile_resolver_to_client(client, resolver)
-        for client in list(getattr(self, "_override_clients", {}).values()):
+        for client in self._owned_clients():
             _attach_provider_endpoint_profile_resolver_to_client(client, resolver)
-        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)
+        self._llm = getattr(getattr(self, "_default_client", None), "_llm", None)
 
     def get_provider_instance(self, *, provider: str, model: str) -> Any:
         """Return the underlying AbstractCore provider instance for (provider, model)."""

abstractruntime-0.10.5/tests/test_endpoint_profile_media_end_to_end.py

@@ -0,0 +1,159 @@
+"""A media spec on an `endpoint:<id>` profile reaches that endpoint, end to end.
+
+The LLM_CALL handler, the pooled client, AbstractCore's capability host and
+the vision plugin's owner-resolver contract are real; only the vision backend
+is a fake that records which endpoint it was given. Both production paths:
+the media-only call without a text provider (the web console sandbox) and
+the call that names its text provider (the Assistant orchestrator).
+"""
+
+from __future__ import annotations
+
+import base64
+import socket
+import subprocess
+from typing import Any, Dict, List, Optional
+
+import pytest
+
+from abstractruntime.core.models import Effect, EffectType, RunState
+from abstractruntime.integrations.abstractcore.effect_handlers import make_llm_call_handler
+from abstractruntime.integrations.abstractcore.llm_client import MultiLocalAbstractCoreLLMClient
+from abstractruntime.storage.artifacts import InMemoryArtifactStore
+
+PNG = base64.b64decode(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/l9sAAAAASUVORK5CYII="
+)
+
+
+def _resolver(key: str):
+    def resolve(provider_id: str) -> Optional[Dict[str, Any]]:
+        if provider_id != "endpoint:relay":
+            return None
+        return {
+            "id": "relay",
+            "virtual_provider": "endpoint:relay",
+            "provider": "openai-compatible",
+            "base_url": "http://127.0.0.1:18921/v1",
+            "api_key": key,
+        }
+
+    return resolve
+
+
+@pytest.fixture
+def pool(tmp_path, monkeypatch):
+    def forbidden(*args, **kwargs):
+        raise AssertionError("an endpoint-profile media spec never opens a socket or spawns the media subprocess")
+
+    monkeypatch.setattr(socket.socket, "connect", forbidden)
+    monkeypatch.setattr(subprocess, "Popen", forbidden)
+    monkeypatch.setenv("ABSTRACTRUNTIME_LOCAL_IMAGE_SUBPROCESS", "1")
+    from abstractcore.capabilities.registry import CapabilityRegistry
+    from abstractcore.config import manager
+
+    config_file = str(tmp_path / "core.json")
+    monkeypatch.setattr(manager, "_config_manager", manager.ConfigurationManager(config_file=config_file, apply_env=False))
+    calls: List[tuple[str, str, str]] = []
+
+    class RecordingVision:
+        backend_id = "test-recording-vision"
+
+        def __init__(self, owner: Any) -> None:
+            self.owner = owner
+
+        def t2i(self, prompt: str, **kwargs: Any) -> bytes:
+            # The vision plugin's contract: `endpoint:<id>` resolves through the
+            # resolver on the OWNING Core provider (the media host's), never
+            # through the Core config file (a gateway profile has no row there).
+            resolved = self.owner.resolve_provider_endpoint_profile(kwargs["provider"])
+            calls.append((kwargs["model"], resolved["base_url"], resolved["api_key"]))
+            return PNG
+
+    monkeypatch.setattr(
+        CapabilityRegistry,
+        "_ensure_plugins_loaded",
+        lambda registry: registry.register_vision_backend(
+            backend_id=RecordingVision.backend_id, factory=RecordingVision, priority=1000
+        ),
+    )
+    store = InMemoryArtifactStore()
+    client = MultiLocalAbstractCoreLLMClient(
+        provider="lmstudio", model="local-model", artifact_store=store, core_config_file=config_file
+    )
+    return client, store, calls
+
+
+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:relay",
+            "model": "gpt-image-2",
+        },
+    }
+    if provider:
+        payload["provider"] = provider
+        payload["model"] = "local-model"
+    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
+
+
+@pytest.mark.parametrize("call_provider", [None, "lmstudio"], ids=["sandbox-media-only", "orchestrator-text-provider"])
+def test_llm_call_image_on_an_endpoint_profile_reaches_it(pool, call_provider) -> None:
+    client, store, calls = pool
+    client.set_provider_endpoint_profile_resolver(_resolver("relay-key"))
+    handler = make_llm_call_handler(llm=client, artifact_store=store)
+
+    outcome = handler(_run(), _image_effect(provider=call_provider), None)
+
+    assert outcome.status == "completed", outcome.error
+    assert calls == [("gpt-image-2", "http://127.0.0.1:18921/v1", "relay-key")]
+    image = outcome.result["outputs"]["image"][0]
+    assert store.load(image["artifact_ref"]["$artifact"]).content == PNG
+    assert "relay-key" not in str(outcome.result)
+
+
+def test_resolver_set_after_the_media_host_exists_and_kept_across_rebuilds(pool) -> None:
+    client, _store, calls = pool
+    media_host = client._media_host_client()
+    client.set_provider_endpoint_profile_resolver(_resolver("first-key"))
+    handler = make_llm_call_handler(llm=client, artifact_store=_store)
+
+    assert handler(_run(), _image_effect(), None).status == "completed"
+    assert calls[-1] == ("gpt-image-2", "http://127.0.0.1:18921/v1", "first-key")
+    assert client._media_host_client() is media_host
+
+    # A profile refresh rotates the resolver on the host that already exists.
+    client.set_provider_endpoint_profile_resolver(_resolver("rotated-key"))
+    assert handler(_run(), _image_effect(), None).status == "completed"
+    assert calls[-1][2] == "rotated-key"
+
+    # Changing the capability routes rebuilds the media host; it is wired like any pooled client.
+    assert client.set_capability_defaults({"output.image": {"provider": "endpoint:relay", "model": "gpt-image-2"}})
+    assert client._media_host_client() is not media_host
+    assert handler(_run(), _image_effect(), None).status == "completed"
+    assert calls[-1][2] == "rotated-key"
+
+
+def test_pool_wide_settings_reach_every_owned_client(pool) -> None:
+    client, _store, _calls = pool
+    media_host = client._media_host_client()
+    assert media_host in client._owned_clients()
+
+    on_token = lambda delta, meta: None  # noqa: E731
+    client.set_on_token(on_token)
+    assert media_host._on_token is on_token
+
+    resolver = _resolver("key")
+    client.set_provider_endpoint_profile_resolver(resolver)
+    assert media_host.resolve_provider_endpoint_profile is resolver
+    assert media_host._llm.resolve_provider_endpoint_profile is resolver

abstractruntime-0.10.4/release-notes.md

@@ -1,15 +0,0 @@
-### 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`.