AbstractRuntime 0.10.3__tar.gz → 0.10.5__tar.gz

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

@@ -5,6 +5,36 @@ 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
+
+- 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

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

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

@@ -356,6 +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. 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.3 → abstractruntime-0.10.5}/llms-full.txt

@@ -1226,6 +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. 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.3 → abstractruntime-0.10.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.10.3"
+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.3 → abstractruntime-0.10.5}/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.3 → 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,15 +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,
-                )
-            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]):
@@ -10837,14 +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)
-        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.5/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.3/release-notes.md

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