induscode 0.1.0__py3-none-any.whl

induscode/runtime_bridge/__init__.py

@@ -0,0 +1,166 @@
+"""Runtime-bridge subsystem — public barrel (port of TS
+``src/runtime-bridge/index.ts``).
+
+Re-exports the FROZEN provider-routing contract: the external-runtime
+annotation (:class:`ExternalRuntimeSpec` + the ``bridge:<adapter>`` endpoint
+convention), the provider-neutral :data:`NormalizedEvent` union, the single
+:class:`BridgeEventSink` push-stream helper, the injectable
+:class:`ChildTransport` boundary, and the routing surface itself
+(:class:`RuntimeBridge`, :class:`RuntimeBroker`, :data:`RuntimeRoute`) —
+plus the behavior modules: the concrete bridges under ``bridges``, the sink
+implementation, and the broker. Consumers import the routing surface from
+``induscode.runtime_bridge`` rather than reaching into individual modules.
+
+Port note: runtime-bridge is consumed only via this barrel (the TS build's
+``src/index.ts: export * as runtimeBridge``) — it is a complete,
+fully-tested library layer not yet wired into the boot path.
+"""
+
+from __future__ import annotations
+
+from induscode.runtime_bridge.bridges import (
+    BUILTIN_ADAPTERS,
+    BUILTIN_RUNTIME_SPECS,
+    CONTINUE,
+    ChildParser,
+    DONE,
+    ParseStep,
+    RuntimeAnnotatedModel,
+    annotate_card,
+    as_record,
+    builtin_runtime_spec,
+    claude_cli_bridge,
+    codex_cli_bridge,
+    drive_exchange,
+    error_text,
+    indusagi_cli_bridge,
+    make_indusagi_cli_bridge,
+    seed_from_model,
+    spec_from_model,
+    str_field,
+    with_runtime_endpoint,
+)
+from induscode.runtime_bridge.broker import (
+    RuntimeBrokerDeps,
+    RuntimeBrokerRuntime,
+    create_runtime_broker,
+    runtime_source_key,
+)
+from induscode.runtime_bridge.contract import (
+    NORMALIZED_EVENT_KINDS,
+    RUNTIME_ENDPOINT_SCHEME,
+    RUNTIME_LINK_ENTRY,
+    Api,
+    AssistantMessage,
+    AssistantMessageEventStream,
+    BridgeEventSink,
+    BridgeFailure,
+    ChildMessage,
+    ChildRequest,
+    ChildTransport,
+    ChildTransportFactory,
+    Context,
+    ExchangeOptions,
+    ExternalRoute,
+    ExternalRuntimeSpec,
+    FailedEvent,
+    FinishEvent,
+    FinishReason,
+    FrameworkRoute,
+    FrameworkStream,
+    KnownProvider,
+    Model,
+    NormalizedEvent,
+    NormalizedEventKind,
+    ResumeEvent,
+    RuntimeAdapterId,
+    RuntimeAuthMode,
+    RuntimeBridge,
+    RuntimeBroker,
+    RuntimeEndpointScheme,
+    RuntimeLink,
+    RuntimeLinkEntryTag,
+    RuntimeLinkStore,
+    RuntimeRoute,
+    SimpleStreamOptions,
+    StopReason,
+    TextEvent,
+    ThinkingEvent,
+    ToolCall,
+    ToolCallEvent,
+    TransportContext,
+    runtime_endpoint,
+)
+from induscode.runtime_bridge.sink import BridgeMessageSeed, create_bridge_sink
+
+__all__ = [
+    "Api",
+    "AssistantMessage",
+    "AssistantMessageEventStream",
+    "BUILTIN_ADAPTERS",
+    "BUILTIN_RUNTIME_SPECS",
+    "BridgeEventSink",
+    "BridgeFailure",
+    "BridgeMessageSeed",
+    "CONTINUE",
+    "ChildMessage",
+    "ChildParser",
+    "ChildRequest",
+    "ChildTransport",
+    "ChildTransportFactory",
+    "Context",
+    "DONE",
+    "ExchangeOptions",
+    "ExternalRoute",
+    "ExternalRuntimeSpec",
+    "FailedEvent",
+    "FinishEvent",
+    "FinishReason",
+    "FrameworkRoute",
+    "FrameworkStream",
+    "KnownProvider",
+    "Model",
+    "NORMALIZED_EVENT_KINDS",
+    "NormalizedEvent",
+    "NormalizedEventKind",
+    "ParseStep",
+    "RUNTIME_ENDPOINT_SCHEME",
+    "RUNTIME_LINK_ENTRY",
+    "ResumeEvent",
+    "RuntimeAdapterId",
+    "RuntimeAnnotatedModel",
+    "RuntimeAuthMode",
+    "RuntimeBridge",
+    "RuntimeBroker",
+    "RuntimeBrokerDeps",
+    "RuntimeBrokerRuntime",
+    "RuntimeEndpointScheme",
+    "RuntimeLink",
+    "RuntimeLinkEntryTag",
+    "RuntimeLinkStore",
+    "RuntimeRoute",
+    "SimpleStreamOptions",
+    "StopReason",
+    "TextEvent",
+    "ThinkingEvent",
+    "ToolCall",
+    "ToolCallEvent",
+    "TransportContext",
+    "annotate_card",
+    "as_record",
+    "builtin_runtime_spec",
+    "claude_cli_bridge",
+    "codex_cli_bridge",
+    "create_bridge_sink",
+    "create_runtime_broker",
+    "drive_exchange",
+    "error_text",
+    "indusagi_cli_bridge",
+    "make_indusagi_cli_bridge",
+    "runtime_endpoint",
+    "runtime_source_key",
+    "seed_from_model",
+    "spec_from_model",
+    "str_field",
+    "with_runtime_endpoint",
+]

induscode/runtime_bridge/bridges/__init__.py

@@ -0,0 +1,66 @@
+"""Bridges subsystem — public barrel (port of TS
+``src/runtime-bridge/bridges/index.ts``).
+
+Bundles the three shipped external-runtime
+:class:`~induscode.runtime_bridge.contract.RuntimeBridge`\\ s — the
+Anthropic-flavoured ``claude-cli``, the OpenAI-flavoured ``codex-cli``, and
+the peer JSON-RPC ``indusagi-cli`` — plus the built-in runtime spec catalog
+and the model-annotation helpers. Consumers register the bridges with a
+:class:`~induscode.runtime_bridge.contract.RuntimeBroker` and annotate
+catalog cards via this barrel rather than reaching into the individual
+modules.
+"""
+
+from __future__ import annotations
+
+# --- Shared driver surface (for bridge authors / tests) ---------------------
+from ._drive import (
+    CONTINUE,
+    DONE,
+    ChildParser,
+    ParseStep,
+    as_record,
+    drive_exchange,
+    error_text,
+    seed_from_model,
+    str_field,
+)
+
+# --- Built-in runtime catalog + annotation ----------------------------------
+from .builtins import (
+    BUILTIN_ADAPTERS,
+    BUILTIN_RUNTIME_SPECS,
+    RuntimeAnnotatedModel,
+    annotate_card,
+    builtin_runtime_spec,
+    spec_from_model,
+    with_runtime_endpoint,
+)
+
+# --- Bridges ----------------------------------------------------------------
+from .claude_cli import claude_cli_bridge
+from .codex_cli import codex_cli_bridge
+from .indusagi_cli import indusagi_cli_bridge, make_indusagi_cli_bridge
+
+__all__ = [
+    "BUILTIN_ADAPTERS",
+    "BUILTIN_RUNTIME_SPECS",
+    "CONTINUE",
+    "ChildParser",
+    "DONE",
+    "ParseStep",
+    "RuntimeAnnotatedModel",
+    "annotate_card",
+    "as_record",
+    "builtin_runtime_spec",
+    "claude_cli_bridge",
+    "codex_cli_bridge",
+    "drive_exchange",
+    "error_text",
+    "indusagi_cli_bridge",
+    "make_indusagi_cli_bridge",
+    "seed_from_model",
+    "spec_from_model",
+    "str_field",
+    "with_runtime_endpoint",
+]

induscode/runtime_bridge/bridges/_drive.py

@@ -0,0 +1,268 @@
+"""Shared exchange driver — the transport-wiring half every bridge reuses
+(port of TS ``src/runtime-bridge/bridges/_drive.ts``).
+
+A bridge is meant to be *only* a per-dialect parser. Two concerns are common
+to all three shipped bridges and are factored here so a bridge never repeats
+them:
+
+1. The lifecycle wiring: subscribe to the
+   :class:`~induscode.runtime_bridge.contract.ChildTransport`, forward each
+   inbound :class:`~induscode.runtime_bridge.contract.ChildMessage` to the
+   bridge's parser, settle the sink on a terminal parser result, honour the
+   caller's :class:`~indusagi._internal.cancel.CancelToken` (the port-wide
+   ``AbortSignal`` replacement), and always dispose the subscription +
+   transport on the way out.
+2. The seed: deriving the
+   :class:`~induscode.runtime_bridge.sink.BridgeMessageSeed` the sink stamps
+   onto the accumulated message from the bound model.
+
+A bridge supplies a :data:`ChildParser` (pure: child payload -> parser
+result) and an opening :class:`~induscode.runtime_bridge.contract.ChildRequest`;
+:func:`drive_exchange` does the rest and returns the populated
+``AssistantMessageEventStream``.
+
+Crucially this module touches the transport only through the injected
+interface — no subprocess module, no spawn. A test hands a fake transport
+and drives the parser end-to-end with zero real binaries.
+
+Async-translation notes (TS -> Python):
+
+- TS ``queueMicrotask`` (the pre-aborted settle, deliberately off-stack so
+  the caller receives the stream before the error lands) becomes
+  ``loop.call_soon``.
+- TS ``void transport.send(request).catch(...)`` / ``void transport.close()``
+  become fire-and-forget asyncio tasks tracked in a module-level set (never
+  bare, so they are not garbage-collected mid-flight) with exceptions routed
+  to the settle path / swallowed respectively.
+- The driver therefore requires a **running event loop** at call time — the
+  Python analogue of the always-present JS microtask queue.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, Final, Literal, TypeAlias
+
+from induscode.runtime_bridge.contract import (
+    AssistantMessageEventStream,
+    BridgeEventSink,
+    BridgeFailure,
+    ChildMessage,
+    ChildRequest,
+    ChildTransport,
+    ExchangeOptions,
+    Model,
+)
+from induscode.runtime_bridge.sink import BridgeMessageSeed, create_bridge_sink
+
+__all__ = [
+    "CONTINUE",
+    "ChildParser",
+    "DONE",
+    "ParseStep",
+    "as_record",
+    "drive_exchange",
+    "error_text",
+    "seed_from_model",
+    "str_field",
+]
+
+
+# ---------------------------------------------------------------------------
+# Parser surface
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class ParseStep:
+    """The outcome a parser reports for one inbound child payload (TS
+    ``ParseStep``). A parser maps a single child payload to the normalized
+    events it produced and whether that payload terminated the exchange.
+
+    - ``"continue"`` — zero or more events were emitted; the stream stays
+      open.
+    - ``"done"`` — the exchange settled (the parser already emitted the
+      ``finish`` / ``failed`` event, or the driver should finish with the
+      default reason). No further payloads are processed.
+    """
+
+    status: Literal["continue", "done"]
+
+
+#: A ``continue`` parse step (no terminal payload).
+CONTINUE: Final = ParseStep(status="continue")
+#: A ``done`` parse step (the payload ended the exchange).
+DONE: Final = ParseStep(status="done")
+
+#: A per-dialect parser: interpret one inbound child payload, drive the sink
+#: with whatever normalized events it yields, and report whether the exchange
+#: is over (TS ``ChildParser``). The parser owns *interpretation* only; it
+#: never touches the framework stream directly — it calls sink methods
+#: (``text`` / ``thinking`` / ``tool_call`` / ``emit`` / ``finish_success`` /
+#: ``finish_error``). Returning :data:`DONE` tells the driver to stop and (if
+#: the sink is not already settled) finish successfully.
+ChildParser: TypeAlias = Callable[[ChildMessage, BridgeEventSink], ParseStep]
+
+
+def seed_from_model(model: Model) -> BridgeMessageSeed:
+    """Derive the message seed the sink stamps onto its accumulated message."""
+    return BridgeMessageSeed(
+        api=str(_model_field(model, "api")),
+        provider=str(_model_field(model, "provider")),
+        model=str(_model_field(model, "id")),
+    )
+
+
+def _model_field(model: Any, key: str) -> Any:
+    """Tolerant model-field read: framework ``Model`` dataclasses (the live
+    path) and plain mappings (test/catalog sources) both work, mirroring JS
+    property access."""
+    if isinstance(model, Mapping):
+        return model.get(key)
+    return getattr(model, key, None)
+
+
+# ---------------------------------------------------------------------------
+# Fire-and-forget task bookkeeping
+# ---------------------------------------------------------------------------
+
+#: Live fire-and-forget tasks (send / close). Held so the event loop cannot
+#: garbage-collect them mid-flight; a done-callback prunes each on settle.
+_PENDING_TASKS: set[asyncio.Task[None]] = set()
+
+
+def _spawn(loop: asyncio.AbstractEventLoop, coro: Any) -> None:
+    task = loop.create_task(coro)
+    _PENDING_TASKS.add(task)
+    task.add_done_callback(_PENDING_TASKS.discard)
+
+
+async def _close_quietly(transport: ChildTransport) -> None:
+    try:
+        await transport.close()
+    except Exception:
+        # best-effort: a close failure must not mask the streamed outcome.
+        pass
+
+
+# ---------------------------------------------------------------------------
+# The driver
+# ---------------------------------------------------------------------------
+
+
+def drive_exchange(
+    model: Model,
+    opts: ExchangeOptions,
+    transport: ChildTransport,
+    request: ChildRequest,
+    parse: ChildParser,
+) -> AssistantMessageEventStream:
+    """Drive a full exchange over an injected transport (TS
+    ``driveExchange``).
+
+    Returns the sink's ``AssistantMessageEventStream`` synchronously; the
+    stream is populated asynchronously as the child emits. The driver:
+
+    - subscribes the parser to inbound messages;
+    - sends the opening request;
+    - settles + tears down on a terminal parse step, transport closure,
+      cancellation, or thrown parser error.
+
+    :param model: the bound model (seeds the sink identity)
+    :param opts: per-exchange options (only ``signal`` is consulted here)
+    :param transport: the injected child boundary
+    :param request: the opening request to send once subscribed
+    :param parse: the per-dialect parser
+    """
+    sink = create_bridge_sink(seed_from_model(model))
+    loop = asyncio.get_running_loop()
+
+    finished = False
+    unsubscribe: Callable[[], None] | None = None
+
+    def teardown() -> None:
+        nonlocal unsubscribe
+        if unsubscribe is not None:
+            unsubscribe()
+            unsubscribe = None
+        _spawn(loop, _close_quietly(transport))
+
+    def settle_success() -> None:
+        nonlocal finished
+        if finished:
+            return
+        finished = True
+        sink.finish_success()
+        teardown()
+
+    def settle_error(message: str, aborted: bool, cause: Any = None) -> None:
+        nonlocal finished
+        if finished:
+            return
+        finished = True
+        sink.finish_error(BridgeFailure(message=message, aborted=aborted, cause=cause))
+        teardown()
+
+    signal = getattr(opts, "signal", None)
+    if signal is not None:
+        if signal.cancelled:
+            # Already cancelled before we started: surface an aborted failure
+            # off-stack (TS queueMicrotask -> loop.call_soon, so the caller
+            # holds the stream before the error lands) and make no transport
+            # calls beyond teardown.
+            loop.call_soon(lambda: settle_error("exchange aborted", True))
+            return sink.stream
+        # CancelToken.add_callback mirrors addEventListener("abort", …,
+        # {once: true}); settle_error is idempotent via the finished flag.
+        signal.add_callback(lambda: settle_error("exchange aborted", True))
+
+    def on_message(message: ChildMessage) -> None:
+        if finished:
+            return
+        try:
+            step = parse(message, sink)
+            if step.status == "done":
+                settle_success()
+        except Exception as cause:
+            settle_error(error_text(cause), False, cause)
+
+    unsubscribe = transport.on_message(on_message)
+
+    # Send the opening request; a send failure ends the exchange in error.
+    async def _send() -> None:
+        try:
+            await transport.send(request)
+        except Exception as cause:
+            settle_error(error_text(cause), False, cause)
+
+    _spawn(loop, _send())
+
+    return sink.stream
+
+
+def error_text(cause: Any) -> str:
+    """Best-effort single-line message for an unknown thrown value (TS
+    ``errorText``)."""
+    if isinstance(cause, BaseException):
+        return str(cause)
+    if isinstance(cause, str):
+        return cause
+    return "external runtime error"
+
+
+# ---------------------------------------------------------------------------
+# Payload-shape helpers (shared by the dialect parsers)
+# ---------------------------------------------------------------------------
+
+
+def as_record(value: Any) -> Mapping[str, Any] | None:
+    """Narrow an opaque payload to a string-keyed record (or ``None``)."""
+    return value if isinstance(value, Mapping) else None
+
+
+def str_field(record: Mapping[str, Any], key: str) -> str | None:
+    """Read a string field off a record, or ``None`` when absent/non-string."""
+    value = record.get(key)
+    return value if isinstance(value, str) else None

induscode/runtime_bridge/bridges/builtins.py

@@ -0,0 +1,177 @@
+"""Built-in external-runtime catalog — the shipped
+:class:`~induscode.runtime_bridge.contract.ExternalRuntimeSpec` entries and
+the helper that *annotates* a model with one (port of TS
+``src/runtime-bridge/bridges/builtins.ts``).
+
+The model catalog (:mod:`induscode.conductor.catalog`) owns the model list;
+this layer never re-catalogues. Instead it carries a small table of the
+three runtimes this build ships and a single sanctioned way to stamp a
+runtime onto a model: rewrite the model's ``baseUrl`` to the synthetic
+``bridge:<adapter>`` endpoint (so a card has a stable, non-HTTP address) and
+return the runtime annotation alongside it.
+
+Why a ``baseUrl`` rewrite rather than a new field on the card: the catalog
+card shape is frozen and the framework ``Model`` has a fixed shape; the
+``bridge:<adapter>`` convention lets a routing consumer recognize a
+runtime-backed model purely from its address
+(``baseUrl.startswith(scheme)``), with the full spec resolved from this
+table — no schema change to the catalog.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any, Final
+
+# The single cross-subsystem import (runtime-bridge → conductor), exactly as
+# in the TS source.
+from induscode.conductor.catalog import CatalogCard
+from induscode.runtime_bridge.contract import (
+    RUNTIME_ENDPOINT_SCHEME,
+    ExternalRuntimeSpec,
+    Model,
+    RuntimeAdapterId,
+    runtime_endpoint,
+)
+
+__all__ = [
+    "BUILTIN_ADAPTERS",
+    "BUILTIN_RUNTIME_SPECS",
+    "RuntimeAnnotatedModel",
+    "annotate_card",
+    "builtin_runtime_spec",
+    "spec_from_model",
+    "with_runtime_endpoint",
+]
+
+
+# ---------------------------------------------------------------------------
+# Shipped runtime specs
+# ---------------------------------------------------------------------------
+
+#: The three runtimes this build ships, keyed by adapter id.
+#:
+#: Each is ``external-cli`` (the spawned child owns its own login), so a
+#: model bound to one is offered as available with an empty credential
+#: vault. The ``binaryPath`` names the default executable the broker
+#: launches when a model's spec does not override it; ``args`` are extra
+#: flags prepended ahead of the bridge's own protocol flags.
+BUILTIN_RUNTIME_SPECS: Final[Mapping[RuntimeAdapterId, ExternalRuntimeSpec]] = {
+    "claude-cli": ExternalRuntimeSpec(
+        adapter="claude-cli",
+        authMode="external-cli",
+        binaryPath="claude",
+        args=("--output-format", "stream-json", "--verbose"),
+    ),
+    "codex-cli": ExternalRuntimeSpec(
+        adapter="codex-cli",
+        authMode="external-cli",
+        binaryPath="codex",
+        args=("--json",),
+    ),
+    "indusagi-cli": ExternalRuntimeSpec(
+        adapter="indusagi-cli",
+        authMode="external-cli",
+        binaryPath="indusagi",
+        args=("--rpc",),
+    ),
+}
+
+#: The shipped adapter ids, in catalog order.
+BUILTIN_ADAPTERS: Final[tuple[RuntimeAdapterId, ...]] = (
+    "claude-cli",
+    "codex-cli",
+    "indusagi-cli",
+)
+
+
+def builtin_runtime_spec(adapter: RuntimeAdapterId) -> ExternalRuntimeSpec | None:
+    """Look up a shipped :class:`ExternalRuntimeSpec` by adapter id
+    (``None`` if none)."""
+    return BUILTIN_RUNTIME_SPECS.get(adapter)
+
+
+# ---------------------------------------------------------------------------
+# Annotation
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class RuntimeAnnotatedModel:
+    """A model annotated with its external runtime (TS
+    ``RuntimeAnnotatedModel``): the rewritten framework model (its
+    ``baseUrl`` now the ``bridge:<adapter>`` synthetic endpoint) paired with
+    the resolved :class:`ExternalRuntimeSpec`. This is the value a routing
+    consumer stores in its side table keyed by canonical id."""
+
+    #: The framework model with its ``baseUrl`` rewritten to the synthetic endpoint.
+    model: Model
+    #: The runtime spec the broker drives this model through.
+    spec: ExternalRuntimeSpec
+
+
+def _model_field(model: Any, key: str) -> Any:
+    """Tolerant model-field read (dataclass attribute or mapping key) —
+    catalog cards retain raw records verbatim, which test sources may supply
+    as plain mappings."""
+    if isinstance(model, Mapping):
+        return model.get(key)
+    return getattr(model, key, None)
+
+
+def with_runtime_endpoint(model: Model, spec: ExternalRuntimeSpec) -> Model:
+    """Rewrite a framework ``Model``'s ``baseUrl`` to the synthetic
+    ``bridge:<adapter>`` endpoint for ``spec.adapter``. Returns a fresh
+    model; the input is never mutated (TS object spread →
+    :func:`dataclasses.replace`)."""
+    endpoint = runtime_endpoint(spec.adapter)
+    if dataclasses.is_dataclass(model) and not isinstance(model, type):
+        return dataclasses.replace(model, baseUrl=endpoint)
+    # Mapping-shaped raw records (test/catalog sources): the TS spread idiom.
+    return {**model, "baseUrl": endpoint}  # type: ignore[return-value]
+
+
+def annotate_card(
+    card: CatalogCard,
+    adapter: RuntimeAdapterId,
+    spec: ExternalRuntimeSpec | None = None,
+) -> RuntimeAnnotatedModel | None:
+    """Annotate one :class:`~induscode.conductor.catalog.CatalogCard` with a
+    runtime spec.
+
+    Resolves the spec from ``spec`` when given explicitly, else from the
+    shipped table by ``adapter``. Returns the card's framework model
+    rewritten to the synthetic endpoint plus the resolved spec, or ``None``
+    when no spec is known for ``adapter`` (so a caller can skip non-runtime
+    adapters).
+
+    :param card: the catalog card whose model to annotate
+    :param adapter: the runtime adapter to bind the model to
+    :param spec: an explicit spec override; defaults to the shipped one
+    """
+    resolved = spec if spec is not None else builtin_runtime_spec(adapter)
+    if resolved is None:
+        return None
+    return RuntimeAnnotatedModel(model=with_runtime_endpoint(card.model, resolved), spec=resolved)
+
+
+def spec_from_model(model: Model) -> ExternalRuntimeSpec | None:
+    """Decode the runtime annotation off a framework ``Model``, the inverse
+    of :func:`with_runtime_endpoint`. Returns the shipped
+    :class:`ExternalRuntimeSpec` for the adapter named in a
+    ``bridge:<adapter>`` ``baseUrl``, or ``None`` when the model is a plain
+    HTTP-provider model (its ``baseUrl`` is a real URL) or the named adapter
+    is not a shipped runtime.
+
+    This is the lookup a broker uses to recognize a runtime-backed model
+    purely from its address.
+
+    :param model: the model whose ``baseUrl`` to inspect
+    """
+    base_url = _model_field(model, "baseUrl")
+    if not isinstance(base_url, str) or not base_url.startswith(RUNTIME_ENDPOINT_SCHEME):
+        return None
+    adapter = base_url[len(RUNTIME_ENDPOINT_SCHEME) :]
+    return builtin_runtime_spec(adapter) if len(adapter) > 0 else None