AbstractRuntime 0.10.3__tar.gz → 0.10.4__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: AbstractRuntime
-Version: 0.10.3
+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.3 → abstractruntime-0.10.4}/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. 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.3 → abstractruntime-0.10.4}/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. 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.3 → abstractruntime-0.10.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "AbstractRuntime"
-version = "0.10.3"
+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.3 → 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.3 → abstractruntime-0.10.4}/src/abstractruntime/integrations/abstractcore/llm_client.py

@@ -10769,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
 
@@ -10844,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_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`.