shiftgate 0.1.8__tar.gz → 0.2.0__tar.gz

{shiftgate-0.1.8 → shiftgate-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shiftgate
-Version: 0.1.8
+Version: 0.2.0
 Summary: Intelligent routing layer that automatically selects the right LoRA adapter for each task in your local agent loop.
 Project-URL: Homepage, https://github.com/shiftgate-ai/shiftgate
 Project-URL: Repository, https://github.com/shiftgate-ai/shiftgate
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110.0
 Requires-Dist: fastembed>=0.3.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: huggingface-hub>=0.22.0
@@ -25,7 +26,9 @@ Requires-Dist: numpy>=1.26.0
 Requires-Dist: pydantic>=2.6.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: scikit-learn>=1.4.0
+Requires-Dist: sse-starlette>=2.1.0
 Requires-Dist: typer>=0.12.0
+Requires-Dist: uvicorn[standard]>=0.29.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
@@ -109,7 +112,60 @@ shiftgate route "write a python sorting function"
 shiftgate run "write a python sorting function"
 ```
 
-**Essential commands:** `init` · `adapter add` · `route` · `run` · `doctor`
+**Essential commands:** `init` · `adapter add` · `route` · `run` · `doctor` · `serve`
+
+---
+
+## Use as an OpenAI-compatible proxy
+
+`shiftgate serve` exposes the router as a drop-in OpenAI endpoint. Any client that speaks OpenAI can point at it and get auto-routing for free — just pass `model="auto"`.
+
+```bash
+# Start the proxy (defaults to http://127.0.0.1:9000)
+shiftgate serve
+```
+
+```python
+# Use it from any OpenAI client
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:9000/v1", api_key="not-needed")
+client.chat.completions.create(
+    model="auto",  # ← shiftgate picks the right adapter
+    messages=[{"role": "user", "content": "write a sql query"}],
+)
+```
+
+When `model="auto"`, shiftgate routes the request to the best adapter and rewrites `model` to that adapter's backend name before forwarding upstream. The response carries an `X-Shiftgate-Route: <adapter_id> (<score>)` header so you can see what was chosen. Passing any other model id bypasses routing and forwards verbatim. Streaming (`stream: true`) is piped straight through via SSE.
+
+```bash
+shiftgate serve --port 9000 --host 127.0.0.1 --backend auto   # backend: auto | ollama | vllm | cerebras
+```
+
+> Bind defaults to `127.0.0.1` (localhost only). Pass `--host 0.0.0.0` to expose it on your network.
+
+### Drop-in for Cursor / Aider / LangChain
+
+Point each tool's OpenAI base URL at the proxy and use `model="auto"`:
+
+```bash
+# Cursor → Settings → Models → Override OpenAI Base URL
+http://localhost:9000/v1
+
+# Aider
+aider --openai-api-base http://localhost:9000/v1 --openai-api-key not-needed --model auto
+```
+
+```python
+# LangChain
+from langchain_openai import ChatOpenAI
+
+llm = ChatOpenAI(
+    base_url="http://localhost:9000/v1",
+    api_key="not-needed",
+    model="auto",
+)
+```
 
 ---
 
@@ -220,6 +276,10 @@ User query
               └────────────────────────────────┘
 ```
 
+### How routing works
+
+When a backend is active, shiftgate filters candidate adapters to only those actually loaded on that backend. Switch from vLLM to Cerebras and shiftgate automatically picks Cerebras-compatible adapters — no re-registration needed. (When you run `shiftgate route` with no backend running, no filtering is applied, so you still see the full routing preview.)
+
 ---
 
 ## Bring Your Own Models
@@ -286,6 +346,20 @@ shiftgate adapter add sql-lora --local /models/sql-lora --tags sql --base llama3
 
 Useful for exploring routing decisions before your backend is set up. To run inference, load the adapter in vLLM or Ollama and re-register with `--runtime`.
 
+### Option 4 — Cerebras (cloud)
+
+shiftgate also supports [Cerebras](https://cerebras.ai/) as a cloud fallback. It uses Cerebras' OpenAI-compatible API and authenticates with a bearer token from the `CEREBRAS_API_KEY` environment variable (or the `--cerebras-key` global flag).
+
+```bash
+export CEREBRAS_API_KEY=csk-...
+shiftgate adapter add llama3.1-8b --runtime llama3.1-8b --tags general --base llama3.1
+shiftgate run "write a python sorting function"
+```
+
+shiftgate auto-detects backends in the order **Ollama → vLLM → Cerebras**, so local backends always win and Cerebras is used only when no local backend is running.
+
+> **Honest status:** shiftgate routes to Cerebras' base-model inference today. When Cerebras Multi-LoRA goes public, register your adapter with `--runtime <cerebras-lora-id>` and it just works — no shiftgate update needed.
+
 ---
 
 ## How to contribute adapters
@@ -393,6 +467,7 @@ shiftgate/
 | `shiftgate route "<query>"`                              | Route a query and show the decision — no inference                    |
 | `shiftgate route "<query>" --explain`                    | Full decision tree: task scores, candidates, selection reason         |
 | `shiftgate run "<query>"`                                | Route + run via Ollama or vLLM                                        |
+| `shiftgate serve [--port 9000] [--host …] [--backend …]` | Run an OpenAI-compatible auto-routing proxy                           |
 | `shiftgate doctor`                                       | Full health check: embedder, backend, adapters, task embeddings       |
 | `shiftgate adapter add <hf_repo> [--tags …] [--base …]`  | Register adapter from HuggingFace (metadata only)                     |
 | `shiftgate adapter add <id> --local <path> [--tags …]`   | Register a local adapter path                                         |

{shiftgate-0.1.8 → shiftgate-0.2.0}/README.md

@@ -76,7 +76,60 @@ shiftgate route "write a python sorting function"
 shiftgate run "write a python sorting function"
 ```
 
-**Essential commands:** `init` · `adapter add` · `route` · `run` · `doctor`
+**Essential commands:** `init` · `adapter add` · `route` · `run` · `doctor` · `serve`
+
+---
+
+## Use as an OpenAI-compatible proxy
+
+`shiftgate serve` exposes the router as a drop-in OpenAI endpoint. Any client that speaks OpenAI can point at it and get auto-routing for free — just pass `model="auto"`.
+
+```bash
+# Start the proxy (defaults to http://127.0.0.1:9000)
+shiftgate serve
+```
+
+```python
+# Use it from any OpenAI client
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:9000/v1", api_key="not-needed")
+client.chat.completions.create(
+    model="auto",  # ← shiftgate picks the right adapter
+    messages=[{"role": "user", "content": "write a sql query"}],
+)
+```
+
+When `model="auto"`, shiftgate routes the request to the best adapter and rewrites `model` to that adapter's backend name before forwarding upstream. The response carries an `X-Shiftgate-Route: <adapter_id> (<score>)` header so you can see what was chosen. Passing any other model id bypasses routing and forwards verbatim. Streaming (`stream: true`) is piped straight through via SSE.
+
+```bash
+shiftgate serve --port 9000 --host 127.0.0.1 --backend auto   # backend: auto | ollama | vllm | cerebras
+```
+
+> Bind defaults to `127.0.0.1` (localhost only). Pass `--host 0.0.0.0` to expose it on your network.
+
+### Drop-in for Cursor / Aider / LangChain
+
+Point each tool's OpenAI base URL at the proxy and use `model="auto"`:
+
+```bash
+# Cursor → Settings → Models → Override OpenAI Base URL
+http://localhost:9000/v1
+
+# Aider
+aider --openai-api-base http://localhost:9000/v1 --openai-api-key not-needed --model auto
+```
+
+```python
+# LangChain
+from langchain_openai import ChatOpenAI
+
+llm = ChatOpenAI(
+    base_url="http://localhost:9000/v1",
+    api_key="not-needed",
+    model="auto",
+)
+```
 
 ---
 
@@ -187,6 +240,10 @@ User query
               └────────────────────────────────┘
 ```
 
+### How routing works
+
+When a backend is active, shiftgate filters candidate adapters to only those actually loaded on that backend. Switch from vLLM to Cerebras and shiftgate automatically picks Cerebras-compatible adapters — no re-registration needed. (When you run `shiftgate route` with no backend running, no filtering is applied, so you still see the full routing preview.)
+
 ---
 
 ## Bring Your Own Models
@@ -253,6 +310,20 @@ shiftgate adapter add sql-lora --local /models/sql-lora --tags sql --base llama3
 
 Useful for exploring routing decisions before your backend is set up. To run inference, load the adapter in vLLM or Ollama and re-register with `--runtime`.
 
+### Option 4 — Cerebras (cloud)
+
+shiftgate also supports [Cerebras](https://cerebras.ai/) as a cloud fallback. It uses Cerebras' OpenAI-compatible API and authenticates with a bearer token from the `CEREBRAS_API_KEY` environment variable (or the `--cerebras-key` global flag).
+
+```bash
+export CEREBRAS_API_KEY=csk-...
+shiftgate adapter add llama3.1-8b --runtime llama3.1-8b --tags general --base llama3.1
+shiftgate run "write a python sorting function"
+```
+
+shiftgate auto-detects backends in the order **Ollama → vLLM → Cerebras**, so local backends always win and Cerebras is used only when no local backend is running.
+
+> **Honest status:** shiftgate routes to Cerebras' base-model inference today. When Cerebras Multi-LoRA goes public, register your adapter with `--runtime <cerebras-lora-id>` and it just works — no shiftgate update needed.
+
 ---
 
 ## How to contribute adapters
@@ -360,6 +431,7 @@ shiftgate/
 | `shiftgate route "<query>"`                              | Route a query and show the decision — no inference                    |
 | `shiftgate route "<query>" --explain`                    | Full decision tree: task scores, candidates, selection reason         |
 | `shiftgate run "<query>"`                                | Route + run via Ollama or vLLM                                        |
+| `shiftgate serve [--port 9000] [--host …] [--backend …]` | Run an OpenAI-compatible auto-routing proxy                           |
 | `shiftgate doctor`                                       | Full health check: embedder, backend, adapters, task embeddings       |
 | `shiftgate adapter add <hf_repo> [--tags …] [--base …]`  | Register adapter from HuggingFace (metadata only)                     |
 | `shiftgate adapter add <id> --local <path> [--tags …]`   | Register a local adapter path                                         |

{shiftgate-0.1.8 → shiftgate-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "shiftgate"
-version = "0.1.8"
+version = "0.2.0"
 description = "Intelligent routing layer that automatically selects the right LoRA adapter for each task in your local agent loop."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -31,6 +31,9 @@ dependencies = [
     "scikit-learn>=1.4.0",
     "httpx>=0.27.0",
     "huggingface-hub>=0.22.0",
+    "fastapi>=0.110.0",
+    "uvicorn[standard]>=0.29.0",
+    "sse-starlette>=2.1.0",
 ]
 
 [project.optional-dependencies]

{shiftgate-0.1.8 → shiftgate-0.2.0}/shiftgate/cli.py

@@ -17,6 +17,7 @@ from typing import Annotated, Optional
 
 import typer
 from rich.console import Console
+from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
 
 from shiftgate.registry.schemas import AdapterEntry, TaskCluster
@@ -39,6 +40,26 @@ app.add_typer(task_app, name="task")
 app.add_typer(feedback_app, name="feedback")
 
 
+@app.callback()
+def _main(
+    cerebras_key: Annotated[
+        Optional[str],
+        typer.Option(
+            "--cerebras-key",
+            help=(
+                "Cerebras API key. If passed, sets CEREBRAS_API_KEY for this run "
+                "so the Cerebras cloud backend becomes available."
+            ),
+        ),
+    ] = None,
+) -> None:
+    """Global options applied before any command runs."""
+    if cerebras_key:
+        import os
+
+        os.environ["CEREBRAS_API_KEY"] = cerebras_key
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
@@ -62,6 +83,19 @@ def _get_embedder():
     return Embedder()
 
 
+def _active_runtimes(backend_router) -> set[str] | None:
+    """Return the set of runtime names loaded on the active backend, or None.
+
+    ``None`` means no backend is active → the router should not filter
+    (preview behaviour).  An empty set means a backend is active but reports no
+    loaded models.
+    """
+    active = backend_router.active_backend
+    if active is None:
+        return None
+    return set(active.list_loaded_adapters())
+
+
 def _auto_link_adapter(adapter: AdapterEntry, task_reg) -> list[str]:
     """Add ``adapter.id`` to the ``preferred_adapters`` of matching task clusters.
 
@@ -443,6 +477,7 @@ def route(
     """
     from shiftgate.feedback import loop as feedback_loop
     from shiftgate.router import router as routing
+    from shiftgate.runtime.backend import BackendRouter
     from shiftgate.utils.display import show_explain_decision, show_routing_decision
 
     task_reg, adapter_reg = _load_registries()
@@ -453,8 +488,15 @@ def route(
 
     embedder = _get_embedder()
 
+    backend_router = BackendRouter()
+    backend_name = backend_router.detect()
+    available_runtimes = _active_runtimes(backend_router)
+
     try:
-        trace, match_result = routing.route(query, task_reg, adapter_reg, embedder, top_k=top_k)
+        trace, match_result = routing.route(
+            query, task_reg, adapter_reg, embedder,
+            top_k=top_k, available_runtimes=available_runtimes,
+        )
     except Exception as exc:
         console.print(f"[red]Routing error:[/red] {exc}")
         raise typer.Exit(1)
@@ -466,7 +508,9 @@ def route(
         trace,
         adapter=adapter,
         task_name=task.name if task else None,
-        backend_name=None,
+        backend_name=backend_name,
+        loaded_runtimes=available_runtimes,
+        selection_method=match_result.selection_method,
     )
 
     if explain:
@@ -503,22 +547,29 @@ def run(
 
     embedder = _get_embedder()
 
+    backend_router = BackendRouter()
+    backend_name = backend_router.detect()
+    available_runtimes = _active_runtimes(backend_router)
+
     try:
-        trace, match_result = routing.route(query, task_reg, adapter_reg, embedder, top_k=top_k)
+        trace, match_result = routing.route(
+            query, task_reg, adapter_reg, embedder,
+            top_k=top_k, available_runtimes=available_runtimes,
+        )
     except Exception as exc:
         console.print(f"[red]Routing error:[/red] {exc}")
         raise typer.Exit(1)
 
     adapter = adapter_reg.get_adapter(trace.selected_adapter_id)
     task = task_reg.get_task(trace.matched_task_id)
-    backend_router = BackendRouter()
-    backend_name = backend_router.detect()
 
     show_routing_decision(
         trace,
         adapter=adapter,
         task_name=task.name if task else None,
         backend_name=backend_name,
+        loaded_runtimes=available_runtimes,
+        selection_method=match_result.selection_method,
     )
 
     if adapter is None:
@@ -705,6 +756,63 @@ def doctor() -> None:
     )
 
 
+# ---------------------------------------------------------------------------
+# shiftgate serve
+# ---------------------------------------------------------------------------
+
+@app.command()
+def serve(
+    port: Annotated[int, typer.Option("--port", help="Port to listen on.")] = 9000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host to bind. Use 0.0.0.0 to expose on the network (default: localhost only).",
+        ),
+    ] = "127.0.0.1",
+    backend: Annotated[
+        str,
+        typer.Option(
+            "--backend",
+            help="Backend to forward to: auto | ollama | vllm | cerebras.",
+        ),
+    ] = "auto",
+) -> None:
+    """Run an OpenAI-compatible proxy that auto-routes `model="auto"` requests.
+
+    Point any OpenAI client (Cursor, Aider, LangChain, the OpenAI SDK) at this
+    URL and pass ``model="auto"`` to get shiftgate routing for free.
+    """
+    import uvicorn
+
+    from shiftgate.serve import create_app
+
+    try:
+        app_instance = create_app(backend=backend)
+    except Exception as exc:
+        console.print(f"[red]Failed to start serve:[/red] {exc}")
+        raise typer.Exit(1)
+
+    backend_router = app_instance.state.backend_router
+    backend_name = backend_router.active_backend_name or "none detected"
+
+    console.print(
+        Panel(
+            f"[bold green]shiftgate serve[/bold green] listening on "
+            f"[cyan]http://{host}:{port}[/cyan]\n"
+            f"backend: [bold]{backend_name}[/bold]\n\n"
+            "Point your OpenAI client at this URL with "
+            "[bold magenta]model='auto'[/bold magenta]:\n"
+            f"  [dim]base_url=\"http://{host}:{port}/v1\"[/dim]",
+            title="OpenAI-compatible proxy",
+            border_style="green",
+            expand=False,
+        )
+    )
+
+    uvicorn.run(app_instance, host=host, port=port, log_level="info")
+
+
 # ---------------------------------------------------------------------------
 # shiftgate demo
 # ---------------------------------------------------------------------------

{shiftgate-0.1.8 → shiftgate-0.2.0}/shiftgate/router/matcher.py

@@ -117,6 +117,7 @@ def top_k_tasks(
 def select_adapter(
     top_tasks: list[TaskMatch],
     adapter_registry,  # AdapterRegistry — avoid circular import with string hint
+    available_runtimes: set[str] | None = None,
 ) -> MatchResult:
     """Select the adapter linked to the best-matching task.
 
@@ -125,15 +126,23 @@ def select_adapter(
     For each top task (highest score first), walk ``preferred_adapters`` then
     ``fallback_adapters`` and collect the adapters that exist in the registry
     (populating ``TaskMatch.candidate_adapters`` for the ``--explain`` view).
-    The first such adapter found, on the highest-scoring task, is selected.
+    The first viable adapter found, on the highest-scoring task, is selected.
+
+    Backend-aware filtering
+    -----------------------
+    When ``available_runtimes`` is provided (the set of model/adapter names
+    actually loaded on the active backend), only adapters whose
+    ``effective_backend_name()`` is in that set are considered viable.  If a
+    task's entire candidate list is filtered out, selection falls through to
+    the next-best task.  When ``available_runtimes`` is ``None`` no filtering
+    happens (the preview behaviour used by ``shiftgate route``).
 
     No silent fallback
     ------------------
     If the matched (top) task has **no** linked adapter in the registry, the
     router must NOT substitute an arbitrary adapter — doing so silently routes,
     e.g., a music query to a SQL adapter and destroys trust.  Instead this
-    returns a ``MatchResult`` with ``selected_adapter=None`` and
-    ``selection_method="no_adapter_for_task"``.
+    returns a ``MatchResult`` with ``selected_adapter=None``.
 
     Parameters
     ----------
@@ -141,39 +150,56 @@ def select_adapter(
         Output of ``top_k_tasks`` (sorted by score descending).
     adapter_registry:
         ``AdapterRegistry`` instance to look up adapter IDs.
+    available_runtimes:
+        Optional set of runtime names loaded on the active backend.  When set,
+        adapters not in the set are skipped during selection.
 
     Returns
     -------
-    ``MatchResult``.  ``selected_adapter`` is ``None`` when no adapter is
-    linked to any of the ranked tasks.  The ``matched_task`` is always the
-    top-scoring task so callers can still report what was matched.
+    ``MatchResult``.  ``selected_adapter`` is ``None`` when no viable adapter is
+    found.  ``selection_method`` is ``"no_adapter_on_active_backend"`` when
+    linked adapters exist but none are loaded on the active backend, otherwise
+    ``"no_adapter_for_task"``.  The ``matched_task`` is always the top-scoring
+    task so callers can still report what was matched.
     """
-    # Populate candidate lists for every task (for the --explain view) and
-    # find the first explicit match in score order.
+    def _is_viable(adapter) -> bool:
+        if available_runtimes is None:
+            return True
+        return adapter.effective_backend_name() in available_runtimes
+
     explicit_result: MatchResult | None = None
+    any_linked_adapter = False  # any task had at least one registered adapter
 
     for tm in top_tasks:
         preferred_ids = list(tm.task.preferred_adapters)
         fallback_ids = list(tm.task.fallback_adapters)
 
+        # Populate candidate_adapters with every registered adapter (for the
+        # --explain view, showing all candidates regardless of runtime).
         for adapter_id in preferred_ids + fallback_ids:
             adapter = adapter_registry.get_adapter(adapter_id)
             if adapter is not None and adapter not in tm.candidate_adapters:
                 tm.candidate_adapters.append(adapter)
 
-        if explicit_result is None and tm.candidate_adapters:
-            method = (
-                "preferred"
-                if tm.candidate_adapters[0].id in tm.task.preferred_adapters
-                else "fallback"
-            )
-            explicit_result = MatchResult(
-                selected_adapter=tm.candidate_adapters[0],
-                matched_task=tm.task,
-                similarity_score=tm.score,
-                all_task_matches=top_tasks,
-                selection_method=method,
-            )
+        if tm.candidate_adapters:
+            any_linked_adapter = True
+
+        if explicit_result is None:
+            viable = [a for a in tm.candidate_adapters if _is_viable(a)]
+            if viable:
+                chosen = viable[0]
+                method = (
+                    "preferred"
+                    if chosen.id in tm.task.preferred_adapters
+                    else "fallback"
+                )
+                explicit_result = MatchResult(
+                    selected_adapter=chosen,
+                    matched_task=tm.task,
+                    similarity_score=tm.score,
+                    all_task_matches=top_tasks,
+                    selection_method=method,
+                )
 
     if explicit_result is not None:
         logger.debug(
@@ -185,19 +211,29 @@ def select_adapter(
         )
         return explicit_result
 
-    # No adapter linked to any ranked task — do NOT guess. Report the matched
-    # task with no adapter so the caller can prompt the user to add one.
+    # No viable adapter across any ranked task. Distinguish "nothing linked at
+    # all" from "linked but not loaded on the active backend".
     top_task = top_tasks[0]
-    logger.info(
-        "No linked adapter for matched task '%s' — refusing to guess.",
-        top_task.task.id,
-    )
+    if available_runtimes is not None and any_linked_adapter:
+        method = "no_adapter_on_active_backend"
+        logger.info(
+            "Linked adapter(s) for task '%s' exist but none are loaded on the "
+            "active backend — refusing to guess.",
+            top_task.task.id,
+        )
+    else:
+        method = "no_adapter_for_task"
+        logger.info(
+            "No linked adapter for matched task '%s' — refusing to guess.",
+            top_task.task.id,
+        )
+
     return MatchResult(
         selected_adapter=None,
         matched_task=top_task.task,
         similarity_score=top_task.score,
         all_task_matches=top_tasks,
-        selection_method="no_adapter_for_task",
+        selection_method=method,
     )
 
 

{shiftgate-0.1.8 → shiftgate-0.2.0}/shiftgate/router/router.py

@@ -26,6 +26,7 @@ def route(
     adapter_registry: AdapterRegistry,
     embedder: Embedder,
     top_k: int = 3,
+    available_runtimes: set[str] | None = None,
 ) -> tuple[RoutingTrace, MatchResult]:
     """Route a query string to the best matching adapter.
 
@@ -48,6 +49,12 @@ def route(
         ``Embedder`` instance (wraps fastembed singleton).
     top_k:
         Number of top task candidates to consider.  Defaults to 3.
+    available_runtimes:
+        Optional set of runtime names loaded on the active backend.  When set,
+        adapters whose ``effective_backend_name()`` is not in the set are
+        skipped, falling through to the next-best task.  If no viable adapter
+        is found across all top-K tasks, the trace's ``selected_adapter_id`` is
+        ``None`` and ``selection_method`` is ``"no_adapter_on_active_backend"``.
 
     Returns
     -------
@@ -73,7 +80,7 @@ def route(
     query_embedding = embedder.embed(query)
     all_tasks = task_registry.get_all_tasks()
     ranked = top_k_tasks(query_embedding, all_tasks, k=top_k)
-    result = select_adapter(ranked, adapter_registry)
+    result = select_adapter(ranked, adapter_registry, available_runtimes=available_runtimes)
 
     selected_id = result.selected_adapter.id if result.selected_adapter else None