anyray-agent 0.1.0__py3-none-any.whl

anyray_agent/__init__.py

@@ -0,0 +1,41 @@
+"""Automatic direct-provider fallback for Anyray gateway clients using httpx2."""
+
+from collections.abc import Callable, Mapping
+from typing import cast
+
+import httpx2
+
+from ._core import AsyncCore, SyncCore
+from ._types import (FALLBACK_LEVELS, AsyncTransport, BedrockOptions, FallbackStatus,
+                     Library, Request, SyncTransport)
+
+__version__ = "0.1.0"
+
+
+class AnyrayTransport(SyncCore, httpx2.BaseTransport):
+    """Wrap a sync transport; caller-supplied inner transports remain caller-owned."""
+
+    def __init__(self, *, provider_keys: Mapping[str, str] | None = None,
+                 bedrock: BedrockOptions | None = None, transport: httpx2.BaseTransport | None = None,
+                 on_status: Callable[[FallbackStatus], None] | None = None) -> None:
+        super().__init__(cast(Library, httpx2), provider_keys=provider_keys, bedrock=bedrock,
+                         transport=cast(SyncTransport | None, transport), on_status=on_status)
+
+    def handle_request(self, request: httpx2.Request) -> httpx2.Response:
+        return cast(httpx2.Response, self.run(self.send(cast(Request, request))))
+
+
+class AsyncAnyrayTransport(AsyncCore, httpx2.AsyncBaseTransport):
+    """Wrap an async transport and cancel its background work on aclose()."""
+
+    def __init__(self, *, provider_keys: Mapping[str, str] | None = None,
+                 bedrock: BedrockOptions | None = None, transport: httpx2.AsyncBaseTransport | None = None,
+                 on_status: Callable[[FallbackStatus], None] | None = None) -> None:
+        super().__init__(cast(Library, httpx2), provider_keys=provider_keys, bedrock=bedrock,
+                         transport=cast(AsyncTransport | None, transport), on_status=on_status)
+
+    async def handle_async_request(self, request: httpx2.Request) -> httpx2.Response:
+        return cast(httpx2.Response, await self.run(self.send(cast(Request, request))))
+
+
+__all__ = ["AnyrayTransport", "AsyncAnyrayTransport", "FallbackStatus", "FALLBACK_LEVELS", "__version__"]

anyray_agent/_bedrock.py

@@ -0,0 +1,168 @@
+"""Bedrock request rewriting, model resolution and SigV4 signing."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import os
+import re
+import threading
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import cast
+from urllib.parse import quote, urlsplit
+
+from . import _runtime
+from ._io import Close, Resolve, Send, Work
+from ._rules import compact, header, provider_key
+from ._types import BedrockOptions, CredentialSource, Library, Request, Response
+
+RESOLVED_MODELS: dict[str, str] = {}
+_CACHE_LOCK = threading.Lock()
+BEDROCK_ID = re.compile(r"^([a-z-]+\.)?anthropic\.|^arn:aws[a-z-]*:bedrock:")
+
+
+def is_bedrock_model(model: str) -> bool:
+    return model.startswith("claude-") or bool(BEDROCK_ID.search(model))
+
+
+@dataclass(frozen=True, repr=False)
+class Keys:
+    access: str
+    secret: str
+    token: str | None
+
+
+def normalize(value: object) -> Keys | None:
+    frozen = getattr(value, "get_frozen_credentials", None)
+    if callable(frozen):
+        value = frozen()
+    if isinstance(value, Mapping):
+        access, secret, token = (value.get(name) for name in ("access_key_id", "secret_access_key", "session_token"))
+    else:
+        access, secret, token = (getattr(value, name, None) for name in ("access_key", "secret_key", "token"))
+    access = provider_key(access) if isinstance(access, str) else None
+    secret = provider_key(secret) if isinstance(secret, str) else None
+    raw_token = token.strip() if isinstance(token, str) else None
+    token = provider_key(raw_token)
+    if not access or not secret or (raw_token and not token):
+        return None
+    return Keys(access, secret, token)
+
+
+def region_prefix(region: str) -> str:
+    if region.startswith("us-gov-"):
+        return ""
+    for family, prefix in (("us-", "us."), ("eu-", "eu."), ("ap-", "apac."), ("ca-", "ca.")):
+        if region.startswith(family):
+            return prefix
+    return ""
+
+
+def sign(url: str, body: bytes, headers: dict[str, str], keys: Keys, region: str) -> None:
+    amz_date = datetime.fromtimestamp(_runtime.now(), timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    date = amz_date[:8]
+    headers["x-amz-date"] = amz_date
+    if keys.token:
+        headers["x-amz-security-token"] = keys.token
+    parts = urlsplit(url)
+    canonical_headers = {name: value for name, value in headers.items() if name != "accept"}
+    canonical_headers["host"] = parts.netloc
+    names = sorted(canonical_headers)
+    signed = ";".join(names)
+    values = {name: re.sub(r"\s+", " ", canonical_headers[name].strip()) for name in names}
+    text = "".join(f"{name}:{values[name]}\n" for name in names)
+    uri = "/".join(quote(part, safe="-_.~") for part in parts.path.split("/"))
+    canonical = f"POST\n{uri}\n\n{text}\n{signed}\n{hashlib.sha256(body).hexdigest()}"
+    scope = f"{date}/{region}/bedrock/aws4_request"
+    to_sign = f"AWS4-HMAC-SHA256\n{amz_date}\n{scope}\n{hashlib.sha256(canonical.encode()).hexdigest()}"
+    key = ("AWS4" + keys.secret).encode()
+    for value in (date, region, "bedrock", "aws4_request"):
+        key = hmac.digest(key, value.encode(), "sha256")
+    signature = hmac.new(key, to_sign.encode(), "sha256").hexdigest()
+    headers["authorization"] = (f"AWS4-HMAC-SHA256 Credential={keys.access}/{scope}, "
+                                f"SignedHeaders={signed}, Signature={signature}")
+
+
+@dataclass(repr=False)
+class Plan:
+    requests: list[Request]
+    cache_key: str | None = None
+    candidates: list[str] | None = None
+    streaming: bool = False
+
+    def execute(self) -> Work[Response]:
+        for index, request in enumerate(self.requests):
+            response = cast(Response, (yield Send(request)))
+            if response.status_code < 400 and self.cache_key and self.candidates:
+                with _CACHE_LOCK:
+                    RESOLVED_MODELS[self.cache_key] = self.candidates[index]
+            retry = response.status_code in (400, 404) and re.match(
+                r"^(ValidationException|ResourceNotFoundException)", header(response.headers, "x-amzn-errortype") or "")
+            if retry and index + 1 < len(self.requests):
+                yield Close(response)
+                continue
+            return response
+        raise RuntimeError("Empty direct plan")
+
+
+class Bedrock:
+    def __init__(self, options: BedrockOptions, *, defer_refresh: bool = False) -> None:
+        self.region = options["region"]
+        if not re.fullmatch(r"[a-z]{2}(-gov)?-[a-z]+-[0-9]+", self.region):
+            raise ValueError("Invalid Bedrock region")
+        self.api_key = provider_key(options.get("api_key")) or provider_key(os.environ.get("AWS_BEARER_TOKEN_BEDROCK"))
+        configured = options.get("credentials")
+        self.source: CredentialSource = configured if configured is not None else {
+            "access_key_id": os.environ.get("AWS_ACCESS_KEY_ID"),
+            "secret_access_key": os.environ.get("AWS_SECRET_ACCESS_KEY"),
+            "session_token": os.environ.get("AWS_SESSION_TOKEN"),
+        }
+        self.models = dict(options.get("models", {}))
+        try:
+            self.available = bool(self.api_key or callable(self.source)
+                                  or (defer_refresh and callable(getattr(self.source, "get_frozen_credentials", None)))
+                                  or normalize(self.source))
+        except Exception:
+            self.available = False
+
+    def plan(self, original: dict[str, object], incoming: Mapping[str, str], extensions: dict[str, object],
+             lib: Library) -> Work[Plan | str]:
+        keys = None
+        if not self.api_key:
+            try:
+                keys = cast(Keys | None, (yield Resolve(self.source)))
+            except Exception:
+                return "no_provider_key"
+            if keys is None:
+                return "no_provider_key"
+        model = cast(str, original["model"])
+        cache_key = f"{self.region}:{model}"
+        with _CACHE_LOCK:
+            known = self.models.get(model, RESOLVED_MODELS.get(cache_key))
+        base = f"{region_prefix(self.region)}anthropic.{model}"
+        candidates = [known] if known is not None else [model] if BEDROCK_ID.search(model) else [base, base + "-v1:0"]
+        body = {name: value for name, value in original.items()
+                if name not in ("model", "stream", "anthropic_version", "anthropic_beta")}
+        body["anthropic_version"] = "bedrock-2023-05-31"
+        betas = [beta.strip() for beta in (header(incoming, "anthropic-beta") or "").split(",") if beta.strip()]
+        if betas:
+            body["anthropic_beta"] = betas
+        content = compact(body).encode()
+        streaming = original.get("stream") is True
+        requests = []
+        for candidate in candidates:
+            # encodeURIComponent leaves these punctuation characters untouched; SigV4 encodes them again.
+            encoded = quote(candidate, safe="-_.!~*'()")
+            action = "invoke-with-response-stream" if streaming else "invoke"
+            url = f"https://bedrock-runtime.{self.region}.amazonaws.com/model/{encoded}/{action}"
+            headers = {"content-type": "application/json",
+                       "accept": "application/vnd.amazon.eventstream" if streaming else "application/json"}
+            if self.api_key:
+                headers["authorization"] = f"Bearer {self.api_key}"
+            elif keys:
+                sign(url, content, headers, keys, self.region)
+            requests.append(lib.Request("POST", url, headers=headers, content=content, extensions=extensions.copy()))
+        # Explicit mappings belong to this transport, never the process-wide cache.
+        return Plan(requests, None if model in self.models else cache_key, candidates, streaming)

anyray_agent/_core.py

@@ -0,0 +1,418 @@
+"""One request flow for both libraries and both concurrency models."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import os
+import threading
+import time
+from collections import OrderedDict
+from collections.abc import Callable, Iterator, Mapping
+from concurrent.futures import Future
+from contextlib import contextmanager
+from typing import TypeVar, cast
+
+from . import _runtime
+from ._bedrock import Bedrock, Plan, normalize
+from ._direct import plan_direct
+from ._event_stream import convert
+from ._io import Close, Effect, Read, Resolve, Send, Wait, Work
+from ._link import Link, Outage, iso
+from ._rules import gateway_answered, gateway_key, key_for, provider_for, provider_key
+from ._types import AsyncTransport, BedrockOptions, FallbackStatus, Library, Request, Response, SyncTransport
+
+T = TypeVar("T")
+
+
+class Core:
+    def __init__(self, lib: Library, *, provider_keys: Mapping[str, str] | None = None,
+                 bedrock: BedrockOptions | None = None, on_status: Callable[[FallbackStatus], None] | None = None) -> None:
+        self.lib = lib
+        self.bedrock = Bedrock(bedrock, defer_refresh=isinstance(self, AsyncCore)) if bedrock is not None else None
+        self.keys = {name: provider_key((provider_keys or {}).get(name)) or provider_key(os.environ.get(env))
+                     for name, env in (("openai", "OPENAI_API_KEY"), ("anthropic", "ANTHROPIC_API_KEY"))}
+        has_keys = bool(self.keys["openai"] or (self.bedrock.available if self.bedrock else self.keys["anthropic"]))
+        self.initial = FallbackStatus("blocked", reason="policy_unknown" if has_keys else "no_provider_key", since=iso())
+        self.delivered = self.initial
+        self.on_status = on_status
+        self.base: str | None = None
+        self.active: Link | None = None
+        self.links: OrderedDict[str, Link] = OrderedDict()
+        self.outage = Outage()
+        self.closed = False
+        self.lock = threading.RLock()
+        self.jobs: list[tuple[Work[object], Future[object]]] = []
+        self.notifications: list[FallbackStatus] = []
+        self.timers: list[tuple[Link, threading.Event]] = []
+
+    @contextmanager
+    def atomic(self) -> Iterator[None]:
+        with self.lock:
+            try:
+                yield
+            finally:
+                jobs, self.jobs = self.jobs, []
+                notifications, self.notifications = self.notifications, []
+                timers, self.timers = self.timers, []
+        for status in notifications:
+            if self.on_status and not self.closed:
+                try:
+                    self.on_status(status)
+                except Exception:
+                    pass
+        for work, future in jobs:
+            self.launch(work, future)
+        for link, stop in timers:
+            self.launch_timer(link, stop)
+
+    def notify(self, link: Link, status: FallbackStatus) -> None:
+        if self.active is link and self.delivered != status:
+            self.delivered = status
+            self.notifications.append(status)
+
+    def schedule(self, work: Work[object], future: Future[object] | None = None) -> None:
+        self.jobs.append((work, future if future is not None else Future()))
+
+    def queue_timer(self, link: Link, stop: threading.Event) -> None:
+        self.timers.append((link, stop))
+
+    def launch(self, work: Work[object], future: Future[object]) -> None:
+        raise NotImplementedError
+
+    def launch_timer(self, link: Link, stop: threading.Event) -> None:
+        raise NotImplementedError
+
+    def status(self) -> FallbackStatus:
+        with self.lock:
+            return self.active.current if self.active else self.initial
+
+    def bind(self, request: Request) -> tuple[Link, str] | None:
+        path = request.url.raw_path.split(b"?", 1)[0].decode("ascii")
+        split = path.find("/v1/")
+        if split < 0:
+            return None
+        base = request.url.scheme + "://" + request.url.netloc.decode("ascii") + path[:split]
+        key = gateway_key(request.headers)
+        if not key:
+            return None
+        with self.atomic():
+            if self.base is not None and self.base != base:
+                return None
+            self.base = base
+            link = self.links.get(key)
+            if link is None:
+                link = Link(self, base, key, self.initial, self.outage)
+                self.links[key] = link
+                if len(self.links) > _runtime.MAX_LINKS:
+                    self.links.popitem(last=False)
+            if self.active is not link:
+                self.active = link
+                self.notify(link, link.current)
+        return link, path[split:]
+
+    def note_keys(self, link: Link, path: str, request: Request) -> None:
+        provider = provider_for(path)
+        if provider:
+            available = self.bedrock.available if provider == "anthropic" and self.bedrock else bool(key_for(provider, request.headers, self.keys))
+            link.note_key(provider, available)
+
+    def direct_plan(self, link: Link, request: Request, path: str, content: bytes | None) -> Work[Plan | None]:
+        plan = yield from plan_direct(request, path, content, self.keys, self.bedrock, self.lib)
+        with self.atomic():
+            if isinstance(plan, str):
+                link.blocked(plan)
+                return None
+            # A policy flip and the decision to send direct must be one atomic transition.
+            if not link.auto_fallback or not link.policy_known or self.closed:
+                return None
+            link.sent_direct()
+        return plan
+
+    def execute(self, plan: Plan) -> Work[Response]:
+        response = yield from plan.execute()
+        # The outer client builds redirects from the original gateway request,
+        # including its credentials. Never let a direct response redirect it.
+        if 300 <= response.status_code < 400 and "location" in response.headers:
+            del response.headers["location"]
+        if plan.streaming and response.status_code == 200:
+            return convert(response, self.lib, isinstance(self, AsyncCore))
+        return response
+
+    def send(self, request: Request) -> Work[Response]:
+        binding = self.bind(request)
+        if binding is None:
+            return cast(Response, (yield Send(request)))
+        link, path = binding
+        try:
+            content: bytes | None = request.content
+        except self.lib.RequestNotRead:
+            content = None
+        attempted_direct = False
+        with self.atomic():
+            switched = link.auto_fallback and link.policy_known and link.outage.switched
+            if switched:
+                self.note_keys(link, path, request)
+                link.touch()
+        if switched:
+            plan = yield from self.direct_plan(link, request, path, content)
+            if plan is not None:
+                attempted_direct = True
+                try:
+                    return (yield from self.execute(plan))
+                except Exception as error:
+                    if not isinstance(error, (self.lib.ConnectError, self.lib.ConnectTimeout)):
+                        raise
+        try:
+            with self.atomic():
+                link.touch()
+            response = cast(Response, (yield Send(request)))
+        except Exception as error:
+            with self.atomic():
+                link.touch()
+                self.note_keys(link, path, request)
+                enabled = link.auto_fallback
+            if not enabled:
+                raise
+            if not isinstance(error, (self.lib.ConnectError, self.lib.ConnectTimeout)):
+                with self.atomic():
+                    link.probe()
+                raise
+            with self.atomic():
+                probe = link.probe()
+            up = yield Wait(probe)
+            if not up and not attempted_direct:
+                with self.atomic():
+                    policy = link.ensure_policy() if link.auto_fallback else None
+                if policy is not None:
+                    yield Wait(policy)
+                with self.atomic():
+                    enabled = link.auto_fallback
+                    known = link.policy_known
+                    if enabled and not known:
+                        link.blocked("policy_unknown")
+                if enabled and known:
+                    plan = yield from self.direct_plan(link, request, path, content)
+                    if plan is not None:
+                        return (yield from self.execute(plan))
+            raise
+        with self.atomic():
+            self.note_keys(link, path, request)
+            if gateway_answered(response.status_code, response.headers):
+                link.healthy()
+            elif link.auto_fallback:
+                link.probe()
+        return response
+
+    def stop(self) -> bool:
+        with self.atomic():
+            if self.closed:
+                return False
+            self.closed = True
+            if self.outage.timer:
+                self.outage.timer.set()
+                self.outage.timer = None
+        return True
+
+
+def advance(work: Work[T], result: object, error: BaseException | None) -> Effect:
+    return work.throw(error) if error is not None else work.send(result)
+
+
+def reject_closed(work: Work[object], future: Future[object]) -> None:
+    work.close()
+    future.set_exception(RuntimeError("Transport is closed"))
+
+
+class SyncCore(Core):
+    def __init__(self, lib: Library, *, transport: SyncTransport | None = None,
+                 provider_keys: Mapping[str, str] | None = None, bedrock: BedrockOptions | None = None,
+                 on_status: Callable[[FallbackStatus], None] | None = None) -> None:
+        super().__init__(lib, provider_keys=provider_keys, bedrock=bedrock, on_status=on_status)
+        self.owned = transport is None
+        self.inner = transport if transport is not None else lib.HTTPTransport()
+        self.threads: set[threading.Thread] = set()
+
+    def run(self, work: Work[T]) -> T:
+        result: object = None
+        error: BaseException | None = None
+        while True:
+            try:
+                effect = advance(work, result, error)
+            except StopIteration as done:
+                return cast(T, done.value)
+            error = None
+            try:
+                result = self.effect(effect)
+            except BaseException as failure:
+                error = failure
+
+    def effect(self, effect: Effect) -> object:
+        if isinstance(effect, Send):
+            if self.closed:
+                raise RuntimeError("Transport is closed")
+            return self.inner.handle_request(effect.request)
+        if isinstance(effect, Read):
+            return effect.response.read()
+        if isinstance(effect, Close):
+            try:
+                effect.response.close()
+            except Exception:
+                pass
+            return None
+        if isinstance(effect, Wait):
+            return effect.future.result()
+        value = effect.source() if callable(effect.source) else effect.source
+        if inspect.isawaitable(value):
+            if inspect.iscoroutine(value):
+                value.close()
+            raise TypeError("Async credentials require AsyncAnyrayTransport")
+        return normalize(value)
+
+    def spawn(self, target: Callable[[], None]) -> bool:
+        def run() -> None:
+            try:
+                target()
+            finally:
+                with self.lock:
+                    self.threads.discard(threading.current_thread())
+        with self.lock:
+            if self.closed:
+                return False
+            thread = threading.Thread(target=run, daemon=True)
+            self.threads.add(thread)
+            thread.start()
+            return True
+
+    def launch(self, work: Work[object], future: Future[object]) -> None:
+        def run() -> None:
+            try:
+                result = self.run(work)
+            except BaseException as error:
+                future.set_exception(error)
+            else:
+                future.set_result(result)
+        if not self.spawn(run):
+            reject_closed(work, future)
+
+    def launch_timer(self, link: Link, stop: threading.Event) -> None:
+        def run() -> None:
+            while not stop.wait(_runtime.PROBE_INTERVAL):
+                with self.atomic():
+                    if self.closed or stop.is_set():
+                        return
+                    future = link.probe()
+                try:
+                    future.result()
+                except Exception:
+                    pass
+        self.spawn(run)
+
+    def close(self) -> None:
+        if not self.stop():
+            return
+        if self.owned:
+            self.inner.close()
+        deadline = time.monotonic() + 0.5
+        with self.lock:
+            threads = list(self.threads)
+        for thread in threads:
+            if thread is not threading.current_thread():
+                thread.join(max(0, deadline - time.monotonic()))
+
+
+class AsyncCore(Core):
+    def __init__(self, lib: Library, *, transport: AsyncTransport | None = None,
+                 provider_keys: Mapping[str, str] | None = None, bedrock: BedrockOptions | None = None,
+                 on_status: Callable[[FallbackStatus], None] | None = None) -> None:
+        super().__init__(lib, provider_keys=provider_keys, bedrock=bedrock, on_status=on_status)
+        self.owned = transport is None
+        self.inner = transport if transport is not None else lib.AsyncHTTPTransport()
+        self.tasks: set[asyncio.Task[None]] = set()
+
+    async def run(self, work: Work[T]) -> T:
+        result: object = None
+        error: BaseException | None = None
+        while True:
+            try:
+                effect = advance(work, result, error)
+            except StopIteration as done:
+                return cast(T, done.value)
+            error = None
+            try:
+                result = await self.effect(effect)
+            except BaseException as failure:
+                error = failure
+
+    async def effect(self, effect: Effect) -> object:
+        if isinstance(effect, Send):
+            if self.closed:
+                raise RuntimeError("Transport is closed")
+            return await self.inner.handle_async_request(effect.request)
+        if isinstance(effect, Read):
+            return await effect.response.aread()
+        if isinstance(effect, Close):
+            try:
+                await effect.response.aclose()
+            except Exception:
+                pass
+            return None
+        if isinstance(effect, Wait):
+            return await asyncio.shield(asyncio.wrap_future(effect.future))
+        source = effect.source
+        if callable(source):
+            asynchronous = inspect.iscoroutinefunction(source) or inspect.iscoroutinefunction(source.__call__)
+            value = source() if asynchronous else await asyncio.to_thread(source)
+        else:
+            value = source
+        if inspect.isawaitable(value):
+            value = await value
+        return await asyncio.to_thread(normalize, value)
+
+    def launch(self, work: Work[object], future: Future[object]) -> None:
+        def finished(task: asyncio.Task[None]) -> None:
+            self.tasks.discard(task)
+            # Cancellation can happen before run() ever enters its try block.
+            if not future.done():
+                reject_closed(work, future)
+
+        async def run() -> None:
+            try:
+                result = await self.run(work)
+            except BaseException as error:
+                future.set_exception(error)
+            else:
+                future.set_result(result)
+        if self.closed:
+            reject_closed(work, future)
+            return
+        task = asyncio.create_task(run())
+        self.tasks.add(task)
+        task.add_done_callback(finished)
+
+    def launch_timer(self, link: Link, stop: threading.Event) -> None:
+        async def run() -> None:
+            try:
+                while not stop.is_set():
+                    await asyncio.sleep(_runtime.PROBE_INTERVAL)
+                    with self.atomic():
+                        if self.closed or stop.is_set():
+                            return
+                        future = link.probe()
+                    await asyncio.shield(asyncio.wrap_future(future))
+            except (Exception, asyncio.CancelledError):
+                pass
+        if not self.closed:
+            task = asyncio.create_task(run())
+            self.tasks.add(task)
+            task.add_done_callback(self.tasks.discard)
+
+    async def aclose(self) -> None:
+        if not self.stop():
+            return
+        tasks = [task for task in self.tasks if task is not asyncio.current_task()]
+        for task in tasks:
+            task.cancel()
+        await asyncio.gather(*tasks, return_exceptions=True)
+        if self.owned:
+            await self.inner.aclose()

anyray_agent/_direct.py

@@ -0,0 +1,60 @@
+"""Plan a replay without changing the original gateway request."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+from ._bedrock import Bedrock, Plan, is_bedrock_model
+from ._io import Work
+from ._rules import ARK, MODELS, ORIGINS, has_gateway_key, key_for, parse_json, provider_for, same_origin
+from ._types import Library, Request
+
+
+def plan_direct(request: Request, path: str, content: bytes | None, keys: Mapping[str, str | None],
+                bedrock: Bedrock | None, lib: Library) -> Work[Plan | str]:
+    provider = provider_for(path)
+    if not provider or request.method.upper() != "POST":
+        return "gateway_only"
+    headers = request.headers
+    if any(name in headers for name in ("x-anyray-provider", "x-anyray-config", "x-anyray-custom-host", "x-anyray-virtual-key")):
+        return "gateway_only"
+    use_bedrock = bedrock if provider == "anthropic" else None
+    if use_bedrock and path != "/v1/messages":
+        return "gateway_only"
+    key = key_for(provider, headers, keys)
+    if not (use_bedrock.available if use_bedrock else key):
+        return "no_provider_key"
+    if content is None:
+        return "body_not_replayable"
+    try:
+        parsed = parse_json(content)
+    except (ValueError, UnicodeError):
+        return "body_not_replayable"
+    if not isinstance(parsed, dict):
+        return "body_not_replayable"
+    body = cast(dict[str, object], parsed)
+    if has_gateway_key(body):
+        return "gateway_only"
+    model = body.get("model")
+    if not isinstance(model, str) or not (is_bedrock_model(model) if use_bedrock else MODELS[provider].search(model)):
+        return "gateway_only"
+    tools = body.get("tools")
+    servers = body.get("mcp_servers")
+    if isinstance(tools, list) and any(isinstance(tool, dict) and tool.get("type") == "mcp"
+                                     and same_origin(tool.get("server_url"), str(request.url)) for tool in tools):
+        return "gateway_only"
+    if isinstance(servers, list) and any(isinstance(server, dict) and same_origin(server.get("url"), str(request.url))
+                                       for server in servers):
+        return "gateway_only"
+    if path == "/v1/responses" and ("previous_response_id" in body or "conversation" in body):
+        return "gateway_only"
+    if use_bedrock:
+        return (yield from use_bedrock.plan(body, headers, request.extensions, lib))
+    direct_headers = {name: value.strip() for name, value in headers.items()
+                      if not name.startswith("x-anyray-") and name not in ("authorization", "x-api-key", "host", "content-length")
+                      and not ARK.search(value)}
+    direct_headers["authorization" if provider == "openai" else "x-api-key"] = f"Bearer {key}" if provider == "openai" else cast(str, key)
+    query = request.url.query.decode("ascii")
+    url = ORIGINS[provider] + path + ("?" + query if query else "")
+    return Plan([lib.Request("POST", url, headers=direct_headers, content=content, extensions=request.extensions.copy())])