Delete _providers

_providers/__init__.py

@@ -1,60 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-"""Provider adapters for first-class chat resources."""
-
-from .anthropic import AnthropicAdapter, AnthropicResourceExecutor
-from .artifact_output import (
-    GeneratedProviderArtifact,
-    OpenAIProviderArtifactOutputExecutor,
-    ProviderArtifactOutputExecutor,
-    ProviderArtifactOutputRegistry,
-    StubProviderArtifactOutputExecutor,
-)
-from .base import ProviderAdapter, ProviderResourceCapabilities, ResourceRoute
-from .custom import CustomAdapter
-from .executor import (
-    PendingProviderExecutor,
-    ProviderChatExecutor,
-    ProviderExecutorRegistry,
-    ProviderPrivateResource,
-    ProviderResourceExecutor,
-    ResourceExecutionError,
-    ResourceExecutionReceipt,
-    ResourceExecutionSession,
-)
-from .gemini import GeminiAdapter, GeminiResourceExecutor
-from .huggingface import HuggingFaceAdapter, HuggingFaceResourceExecutor
-from .openai import OpenAIAdapter, OpenAIResourceExecutor
-from .registry import ProviderRegistry, StaticProviderAdapter
-from .self_hosted import SelfHostedAdapter
-
-__all__ = [
-    "AnthropicAdapter",
-    "AnthropicResourceExecutor",
-    "CustomAdapter",
-    "GeminiAdapter",
-    "GeminiResourceExecutor",
-    "GeneratedProviderArtifact",
-    "HuggingFaceAdapter",
-    "HuggingFaceResourceExecutor",
-    "OpenAIAdapter",
-    "OpenAIProviderArtifactOutputExecutor",
-    "OpenAIResourceExecutor",
-    "PendingProviderExecutor",
-    "ProviderAdapter",
-    "ProviderArtifactOutputExecutor",
-    "ProviderArtifactOutputRegistry",
-    "ProviderChatExecutor",
-    "ProviderExecutorRegistry",
-    "ProviderPrivateResource",
-    "ProviderRegistry",
-    "ProviderResourceCapabilities",
-    "ProviderResourceExecutor",
-    "ResourceExecutionError",
-    "ResourceExecutionReceipt",
-    "ResourceExecutionSession",
-    "ResourceRoute",
-    "SelfHostedAdapter",
-    "StaticProviderAdapter",
-    "StubProviderArtifactOutputExecutor",
-]

_providers/anthropic.py

@@ -1,511 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Anthropic Files + Messages resource executor.
-
-Uploaded file identifiers are workspace-level provider capabilities and remain
-strictly request-private.  They never enter browser responses, health metadata,
-logs, receipts, persistence, or exports.
-"""
-
-from __future__ import annotations
-
-import json
-import secrets
-from collections.abc import AsyncIterator, Sequence
-from urllib.parse import quote, urlparse
-
-import httpx
-
-from .executor import ProviderPrivateResource, ResourceExecutionError
-from .policy import anthropic_code_execution_supported_model
-from .registry import StaticProviderAdapter
-
-try:
-    from .._utils._chat_contract import ChatRequest, build_upstream_payload
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._chat_contract import ChatRequest, build_upstream_payload
-    from _utils._resource_transport import ResourceUpload
-
-_ANTHROPIC_BASE = "https://api.anthropic.com"
-_ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages"
-_ANTHROPIC_VERSION = "2023-06-01"
-_UPLOAD_CHUNK_BYTES = 1024 * 1024
-_MIN_EXPIRES_SECONDS = 3600
-_MAX_EXPIRES_SECONDS = 90 * 24 * 60 * 60
-_MAX_FILE_BYTES = 500_000_000
-_MAX_SSE_EVENT_BYTES = 1024 * 1024
-_CODE_EXECUTION_TOOL = "code_execution_20260521"
-_IMAGE_MIMES = frozenset({"image/jpeg", "image/png", "image/gif", "image/webp"})
-
-
-class AnthropicAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("anthropic", **kwargs)
-
-
-def _validated_anthropic_base(value: str) -> str:
-    raw = str(value or _ANTHROPIC_BASE).rstrip("/")
-    parsed = urlparse(raw)
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "api.anthropic.com"
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.port not in {None, 443}
-        or parsed.query
-        or parsed.fragment
-        or parsed.path not in {"", "/"}
-    ):
-        raise ValueError(
-            "Anthropic resource executor requires the official HTTPS API origin"
-        )
-    return _ANTHROPIC_BASE
-
-
-def official_anthropic_messages_backend(value: str) -> bool:
-    """Return whether Path-1 points exactly at the official Messages URL."""
-    raw = str(value or "").strip().rstrip("/")
-    try:
-        parsed = urlparse(raw)
-    except ValueError:
-        return False
-    return bool(
-        parsed.scheme == "https"
-        and parsed.hostname == "api.anthropic.com"
-        and parsed.username is None
-        and parsed.password is None
-        and parsed.port in {None, 443}
-        and not parsed.query
-        and not parsed.fragment
-        and parsed.path.rstrip("/") == "/v1/messages"
-        and raw == _ANTHROPIC_MESSAGES_URL
-    )
-
-
-def _safe_provider_file_id(value: object) -> str:
-    """Validate one opaque provider file ID without assuming a prefix/format."""
-    if (
-        not isinstance(value, str)
-        or not value
-        or value != value.strip()
-        or len(value) > 512  # ruff: ignore[magic-value-comparison]
-    ):
-        raise ResourceExecutionError("Anthropic private file handle is invalid")
-    if any(
-        ord(ch) < 0x20 or ord(ch) == 0x7F  # ruff: ignore[magic-value-comparison]
-        for ch in value
-    ):
-        raise ResourceExecutionError("Anthropic private file handle is invalid")
-    if any(ch in value for ch in "/\\?#&"):
-        raise ResourceExecutionError("Anthropic private file handle is invalid")
-    return value
-
-
-def _opaque_file_id(handle: ProviderPrivateResource) -> str:
-    opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-    return _safe_provider_file_id(opaque.get("file_id"))
-
-
-def _upload_mime(upload: ResourceUpload) -> str:
-    verified = upload.verified
-    if verified.detected_modality == "text":
-        return "text/plain"
-    return verified.detected_mime or "application/octet-stream"
-
-
-def _multipart_header(
-    boundary: str, *, seconds: int, upload: ResourceUpload
-) -> tuple[bytes, bytes]:
-    verified = upload.verified
-    safe_name = (
-        verified.name.replace('"', "_").replace("\r", " ").replace("\n", " ")[:500]
-        or "resource"
-    )
-    prefix = (
-        f"--{boundary}\r\n"
-        'Content-Disposition: form-data; name="expires_in_seconds"\r\n\r\n'
-        f"{seconds}\r\n"
-        f"--{boundary}\r\n"
-        f'Content-Disposition: form-data; name="file"; filename="{safe_name}"\r\n'
-        f"Content-Type: {_upload_mime(upload)}\r\n\r\n"
-    ).encode()
-    suffix = f"\r\n--{boundary}--\r\n".encode("ascii")
-    return prefix, suffix
-
-
-def _bounded_json_bytes(payload: dict) -> bytes:
-    return json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode(
-        "utf-8"
-    )
-
-
-def _message_text(payload: object) -> str:
-    if not isinstance(payload, dict):
-        raise ResourceExecutionError("Anthropic Messages returned invalid metadata")
-    if payload.get("type") == "error" or payload.get("error"):
-        raise ResourceExecutionError("Anthropic Messages reported a provider failure")
-    pieces: list[str] = []
-    content = payload.get("content")
-    if isinstance(content, list):
-        for block in content:
-            if (
-                isinstance(block, dict)
-                and block.get("type") == "text"
-                and isinstance(block.get("text"), str)
-            ):
-                pieces.append(block["text"])
-    text = "".join(pieces)
-    if not text:
-        raise ResourceExecutionError("Anthropic Messages returned no assistant text")
-    return text
-
-
-class AnthropicResourceExecutor:
-    """Upload verified resources to Files and execute Claude Messages."""
-
-    name = "anthropic"
-    enabled = True
-
-    def __init__(
-        self,
-        *,
-        api_key: str,
-        client: httpx.AsyncClient,
-        base_url: str = _ANTHROPIC_BASE,
-        expires_seconds: int = _MIN_EXPIRES_SECONDS,
-        response_timeout_seconds: float = 600.0,
-    ) -> None:
-        key = str(api_key or "").strip()
-        if not key:
-            raise ValueError("Anthropic API key is required")
-        self._api_key = key
-        self._client = client
-        self._base = _validated_anthropic_base(base_url)
-        self._expires = max(
-            _MIN_EXPIRES_SECONDS, min(int(expires_seconds), _MAX_EXPIRES_SECONDS)
-        )
-        self._response_timeout = httpx.Timeout(
-            connect=20.0,
-            read=max(30.0, min(float(response_timeout_seconds), 1800.0)),
-            write=120.0,
-            pool=20.0,
-        )
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        routes: dict[str, tuple[str, ...]] = {
-            "text": ("native",),
-            "image": ("native",),
-            "animated_image": ("native",),
-            "document": ("native",),
-        }
-        if anthropic_code_execution_supported_model(model):
-            for modality in ("vector_image", "data", "archive", "binary"):
-                routes[modality] = ("tool",)
-        return routes
-
-    def _headers(self) -> dict[str, str]:
-        return {
-            "x-api-key": self._api_key,
-            "anthropic-version": _ANTHROPIC_VERSION,
-            "Accept": "application/json",
-        }
-
-    async def _body(self, prefix: bytes, suffix: bytes, upload: ResourceUpload):
-        await upload.upload.seek(0)
-        try:
-            yield prefix
-            while True:
-                chunk = await upload.upload.read(_UPLOAD_CHUNK_BYTES)
-                if not chunk:
-                    break
-                yield chunk
-            yield suffix
-        finally:
-            await upload.upload.seek(0)
-
-    async def prepare(
-        self, *, model: str, route, upload: ResourceUpload
-    ) -> ProviderPrivateResource:
-        del model
-        verified = upload.verified
-        if route.resource_id != verified.id or route.route not in {"native", "tool"}:
-            raise ResourceExecutionError(
-                "Anthropic executor received an invalid resource route"
-            )
-        if int(verified.actual_size) > _MAX_FILE_BYTES:
-            raise ResourceExecutionError(
-                "Anthropic file exceeds the bounded 500 MB provider limit"
-            )
-        boundary = "scikitplots-" + secrets.token_hex(16)
-        prefix, suffix = _multipart_header(
-            boundary, seconds=self._expires, upload=upload
-        )
-        headers = self._headers()
-        headers.update(
-            {
-                "Content-Type": f"multipart/form-data; boundary={boundary}",
-                "Content-Length": str(len(prefix) + verified.actual_size + len(suffix)),
-            }
-        )
-        try:
-            response = await self._client.post(
-                f"{self._base}/v1/files",
-                headers=headers,
-                content=self._body(prefix, suffix, upload),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Anthropic temporary file upload failed"
-            ) from exc
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError("Anthropic temporary file upload was rejected")
-        try:
-            payload = response.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Anthropic temporary file upload returned invalid metadata"
-            ) from exc
-        if not isinstance(payload, dict):
-            raise ResourceExecutionError(
-                "Anthropic temporary file upload returned invalid metadata"
-            )
-        file_id = _safe_provider_file_id(payload.get("id"))
-        returned_bytes = payload.get("size_bytes")
-        if returned_bytes is not None:
-            try:
-                if int(returned_bytes) != int(verified.actual_size):
-                    raise ResourceExecutionError(
-                        "Anthropic temporary file size did not match source bytes"
-                    )
-            except (TypeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "Anthropic temporary file size metadata was invalid"
-                ) from exc
-        return ProviderPrivateResource(
-            resource_id=verified.id,
-            route=route.route,
-            provider=self.name,
-            source_sha256=verified.sha256,
-            source_size=verified.actual_size,
-            opaque={
-                "file_id": file_id,
-                "modality": verified.detected_modality,
-                "mime": _upload_mime(upload),
-                "name": verified.name,
-            },
-            cleanup_required=True,
-        )
-
-    async def release(self, handle: ProviderPrivateResource) -> None:
-        file_id = _opaque_file_id(handle)
-        try:
-            response = await self._client.delete(
-                f"{self._base}/v1/files/{quote(file_id, safe='')}",
-                headers=self._headers(),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Anthropic temporary file cleanup failed"
-            ) from exc
-        if response.status_code == 404:  # ruff: ignore[magic-value-comparison]
-            handle.released = True
-            return
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError(
-                "Anthropic temporary file cleanup was rejected"
-            )
-        try:
-            payload = response.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Anthropic temporary file cleanup returned invalid metadata"
-            ) from exc
-        if not isinstance(payload, dict) or payload.get("type") != "file_deleted":
-            raise ResourceExecutionError(
-                "Anthropic temporary file cleanup was not confirmed"
-            )
-        handle.released = True
-
-    def messages_payload(
-        self, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> dict:
-        provider_body = build_upstream_payload(chat, reasoning_enabled=False)
-        messages = provider_body.get("messages", [])
-        system = str(messages[0].get("content", "")) if len(messages) > 0 else ""
-        user_text = (
-            str(messages[1].get("content", ""))
-            if len(messages) > 1
-            else chat.user_message
-        )
-        content: list[dict] = [{"type": "text", "text": user_text}]
-        tool_needed = False
-
-        for handle in handles:
-            file_id = _opaque_file_id(handle)
-            opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-            modality = str(opaque.get("modality", ""))
-            mime = str(opaque.get("mime", ""))
-            if handle.route == "tool":
-                if not anthropic_code_execution_supported_model(chat.model):
-                    raise ResourceExecutionError(
-                        "Anthropic Code Execution is not enabled for this model"
-                    )
-                content.append({"type": "container_upload", "file_id": file_id})
-                tool_needed = True
-                continue
-            if handle.route != "native":
-                raise ResourceExecutionError(
-                    "Anthropic Messages received a non-executable route"
-                )
-            if modality in {"text", "document"}:
-                if modality == "document" and mime != "application/pdf":
-                    raise ResourceExecutionError(
-                        "Anthropic native document route supports PDF or plain text only"
-                    )
-                content.append(
-                    {"type": "document", "source": {"type": "file", "file_id": file_id}}
-                )
-                continue
-            if modality in {"image", "animated_image"} and mime in _IMAGE_MIMES:
-                content.append(
-                    {"type": "image", "source": {"type": "file", "file_id": file_id}}
-                )
-                continue
-            raise ResourceExecutionError(
-                "Anthropic native route does not support this modality"
-            )
-
-        payload: dict = {
-            "model": chat.model,
-            "system": system,
-            "messages": [{"role": "user", "content": content}],
-            "max_tokens": chat.max_tokens,
-            "stream": bool(chat.stream),
-        }
-        if tool_needed:
-            payload["tools"] = [
-                {"type": _CODE_EXECUTION_TOOL, "name": "code_execution"}
-            ]
-        return payload
-
-    async def open_chat(
-        self, *, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> httpx.Response:
-        payload = self.messages_payload(chat, handles)
-        headers = self._headers()
-        headers["Content-Type"] = "application/json"
-        request = self._client.build_request(
-            "POST",
-            f"{self._base}/v1/messages",
-            headers=headers,
-            content=_bounded_json_bytes(payload),
-            timeout=self._response_timeout,
-        )
-        try:
-            return await self._client.send(request, stream=True)
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError("Anthropic Messages request failed") from exc
-
-    async def buffered_chat_response(
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> dict:
-        total = 0
-        chunks: list[bytes] = []
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                raise ResourceExecutionError(
-                    "Anthropic Messages body exceeded the configured response limit"
-                )
-            chunks.append(chunk)
-        try:
-            payload = json.loads(b"".join(chunks))
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Anthropic Messages returned invalid JSON"
-            ) from exc
-        text = _message_text(payload)
-        return {
-            "choices": [{"message": {"role": "assistant", "content": text}}],
-            "model": (
-                str(payload.get("model", "") or "") if isinstance(payload, dict) else ""
-            ),
-        }
-
-    async def chat_sse(  # ruff: ignore[too-many-branches]
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> AsyncIterator[bytes]:
-        total = 0
-        buffer = bytearray()
-        completed = False
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_RESPONSE_TOO_LARGE","message":"The upstream response exceeded the configured limit."}}\n\n'
-                return
-            buffer.extend(chunk)
-            if (
-                len(buffer) > _MAX_SSE_EVENT_BYTES
-                and b"\n\n" not in buffer
-                and b"\r\n\r\n" not in buffer
-            ):
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_EVENT_TOO_LARGE","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                return
-            while True:
-                pos_lf = buffer.find(b"\n\n")
-                pos_crlf = buffer.find(b"\r\n\r\n")
-                positions = [(pos_lf, 2), (pos_crlf, 4)]
-                positions = [(pos, width) for pos, width in positions if pos >= 0]
-                if not positions:
-                    break
-                pos, width = min(positions, key=lambda row: row[0])
-                if pos > _MAX_SSE_EVENT_BYTES:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_EVENT_TOO_LARGE","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                    return
-                raw = bytes(buffer[:pos])
-                del buffer[: pos + width]
-                event = ""
-                data_lines: list[bytes] = []
-                for line in raw.replace(b"\r\n", b"\n").split(b"\n"):
-                    if line.startswith(b"event:"):
-                        event = line[6:].strip().decode("utf-8", "replace")
-                    elif line.startswith(b"data:"):
-                        data_lines.append(line[5:].lstrip())
-                if event == "message_stop":
-                    completed = True
-                    yield b"data: [DONE]\n\n"
-                    return
-                if event == "error":
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROVIDER_ERROR","message":"The upstream provider stream failed."}}\n\n'
-                    return
-                if not data_lines:
-                    continue
-                try:
-                    payload = json.loads(b"\n".join(data_lines))
-                except (json.JSONDecodeError, ValueError):
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_STREAM_INVALID","message":"The upstream provider stream was malformed."}}\n\n'
-                    return
-                if event == "content_block_delta" and isinstance(payload, dict):
-                    delta = payload.get("delta")
-                    if (
-                        isinstance(delta, dict)
-                        and delta.get("type") == "text_delta"
-                        and isinstance(delta.get("text"), str)
-                    ):
-                        frame = json.dumps(
-                            {"choices": [{"delta": {"content": delta["text"]}}]},
-                            ensure_ascii=False,
-                            separators=(",", ":"),
-                        ).encode("utf-8")
-                        yield b"data: " + frame + b"\n\n"
-        if not completed:
-            yield b'event: error\ndata: {"error":{"code":"UPSTREAM_STREAM_INCOMPLETE","message":"The upstream provider stream ended before completion."}}\n\n'

_providers/artifact_output.py

@@ -1,502 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-First-class provider binary artifact output executors.
-
-Output generation is intentionally separate from chat/resource input routing.
-Input modality support never implies write/output authority.  Only executors
-registered here may produce bytes for ``/v1/artifacts/provider-output``.
-"""
-
-from __future__ import annotations
-
-import base64
-import hashlib
-import io
-import json
-import math
-import struct
-import tempfile
-import wave
-import zlib
-from dataclasses import dataclass
-from typing import Protocol, Sequence
-
-import httpx
-
-try:
-    from .._utils._provider_artifact import (
-        PROVIDER_ARTIFACT_MAX_OUTPUT_BYTES,
-        ProviderArtifactError,
-        ProviderArtifactGeneratorSpec,
-        ProviderArtifactReceipt,
-        ProviderArtifactRequest,
-        build_provider_artifact_receipt_from_digest,
-        validate_provider_artifact_signature,
-    )
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._provider_artifact import (
-        PROVIDER_ARTIFACT_MAX_OUTPUT_BYTES,
-        ProviderArtifactError,
-        ProviderArtifactGeneratorSpec,
-        ProviderArtifactReceipt,
-        ProviderArtifactRequest,
-        build_provider_artifact_receipt_from_digest,
-        validate_provider_artifact_signature,
-    )
-
-_OPENAI_IMAGE_URL = "https://api.openai.com/v1/images/generations"
-_OPENAI_SPEECH_URL = "https://api.openai.com/v1/audio/speech"
-_OPENAI_IMAGE_MODEL = "gpt-image-2"
-_OPENAI_TTS_MODEL = "gpt-4o-mini-tts"
-_IMAGE_MAX_OUTPUT = 16 * 1024 * 1024
-_AUDIO_MAX_OUTPUT = 32 * 1024 * 1024
-_IMAGE_JSON_MAX = 24 * 1024 * 1024
-_COPY_CHUNK = 1024 * 1024
-
-
-@dataclass
-class GeneratedProviderArtifact:
-    file: tempfile.SpooledTemporaryFile
-    receipt: ProviderArtifactReceipt
-    filename: str
-
-    def close(self) -> None:
-        self.file.close()
-
-
-class ProviderArtifactOutputExecutor(Protocol):
-    name: str
-    enabled: bool
-
-    def specs(self) -> Sequence[ProviderArtifactGeneratorSpec]: ...
-
-    async def generate(
-        self, request: ProviderArtifactRequest
-    ) -> GeneratedProviderArtifact: ...
-
-
-class ProviderArtifactOutputRegistry:
-    """Generator-id registry separated from resource/chat execution authority."""
-
-    def __init__(self) -> None:
-        self._executors: dict[str, ProviderArtifactOutputExecutor] = {}
-        self._specs: dict[str, ProviderArtifactGeneratorSpec] = {}
-
-    def clear(self) -> None:
-        self._executors.clear()
-        self._specs.clear()
-
-    def register(self, executor: ProviderArtifactOutputExecutor) -> None:
-        if not bool(getattr(executor, "enabled", False)):
-            raise ValueError("provider artifact executor is disabled")
-        rows = tuple(executor.specs())
-        if not rows:
-            raise ValueError("provider artifact executor exposes no generators")
-        for spec in rows:
-            if spec.id in self._specs:
-                raise ValueError("duplicate provider artifact generator id")
-            self._specs[spec.id] = spec
-            self._executors[spec.id] = executor
-
-    def public_specs(self) -> tuple[ProviderArtifactGeneratorSpec, ...]:
-        return tuple(self._specs[key] for key in sorted(self._specs))
-
-    def spec(self, generator_id: str) -> ProviderArtifactGeneratorSpec | None:
-        return self._specs.get(str(generator_id or ""))
-
-    async def generate(
-        self, request: ProviderArtifactRequest
-    ) -> GeneratedProviderArtifact:
-        executor = self._executors.get(request.generator_id)
-        spec = self._specs.get(request.generator_id)
-        if executor is None or spec is None:
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_GENERATOR_UNAVAILABLE")
-        if request.kind != spec.kind or request.mime_type not in spec.mime_types:
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_CAPABILITY_MISMATCH")
-        artifact = await executor.generate(request)
-        try:
-            validate_provider_artifact_signature(
-                artifact.file, request.mime_type, artifact.receipt.output_size
-            )
-        except Exception:
-            artifact.close()
-            raise
-        artifact.file.seek(0)
-        return artifact
-
-
-def _png_bytes(prompt: str) -> bytes:
-    """Return a deterministic 32x32 RGB PNG without third-party image libraries."""
-    digest = hashlib.sha256(prompt.encode("utf-8")).digest()
-    width = height = 32
-    rows = bytearray()
-    for y in range(height):
-        rows.append(0)
-        for x in range(width):
-            rows.extend(
-                (
-                    digest[(x + y) % 32],
-                    digest[(x * 3 + y) % 32],
-                    digest[(x + y * 5) % 32],
-                )
-            )
-    raw = zlib.compress(bytes(rows), level=9)
-
-    def chunk(kind: bytes, payload: bytes) -> bytes:
-        return (
-            struct.pack(">I", len(payload))
-            + kind
-            + payload
-            + struct.pack(">I", zlib.crc32(kind + payload) & 0xFFFFFFFF)
-        )
-
-    return (
-        b"\x89PNG\r\n\x1a\n"
-        + chunk(b"IHDR", struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0))
-        + chunk(b"IDAT", raw)
-        + chunk(b"IEND", b"")
-    )
-
-
-def _wav_bytes(prompt: str) -> bytes:
-    """Return a deterministic short PCM WAV fixture derived from the prompt."""
-    digest = hashlib.sha256(prompt.encode("utf-8")).digest()
-    rate = 8000
-    duration = 0.20
-    frames = int(rate * duration)
-    freq = 300 + digest[0]
-    out = io.BytesIO()
-    with wave.open(out, "wb") as wav:
-        wav.setnchannels(1)
-        wav.setsampwidth(2)
-        wav.setframerate(rate)
-        samples = bytearray()
-        for i in range(frames):
-            value = int(8000 * math.sin(2 * math.pi * freq * i / rate))
-            samples.extend(struct.pack("<h", value))
-        wav.writeframes(bytes(samples))
-    return out.getvalue()
-
-
-def _artifact_from_bytes(
-    *,
-    request: ProviderArtifactRequest,
-    spec: ProviderArtifactGeneratorSpec,
-    payload: bytes,
-    filename: str,
-) -> GeneratedProviderArtifact:
-    if not payload or len(payload) > min(
-        spec.max_output_bytes, PROVIDER_ARTIFACT_MAX_OUTPUT_BYTES
-    ):
-        raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_TOO_LARGE")
-    spool = (
-        # lint
-        tempfile.SpooledTemporaryFile(  # ruff: ignore[open-file-with-context-handler]
-            max_size=8 * 1024 * 1024,
-            mode="w+b",
-        )
-    )
-    spool.write(payload)
-    spool.seek(0)
-    receipt = build_provider_artifact_receipt_from_digest(
-        request=request,
-        spec=spec,
-        output_size=len(payload),
-        output_sha256=hashlib.sha256(payload).hexdigest(),
-    )
-    return GeneratedProviderArtifact(file=spool, receipt=receipt, filename=filename)
-
-
-class StubProviderArtifactOutputExecutor:
-    """Deterministic credential-free generator used only when the stub rig is enabled."""
-
-    name = "stub"
-    enabled = True
-
-    _SPECS = (
-        ProviderArtifactGeneratorSpec(
-            id="stub/generated-png",
-            provider="stub",
-            model="deterministic-png",
-            kind="image",
-            diagnostic=True,
-            mime_types=("image/png",),
-            max_output_bytes=1024 * 1024,
-            option_schema={},
-        ),
-        ProviderArtifactGeneratorSpec(
-            id="stub/generated-wav",
-            provider="stub",
-            model="deterministic-wav",
-            kind="audio",
-            diagnostic=True,
-            mime_types=("audio/wav",),
-            max_output_bytes=1024 * 1024,
-            option_schema={},
-        ),
-    )
-
-    def specs(self) -> Sequence[ProviderArtifactGeneratorSpec]:
-        return self._SPECS
-
-    async def generate(
-        self, request: ProviderArtifactRequest
-    ) -> GeneratedProviderArtifact:
-        spec = next(
-            (row for row in self._SPECS if row.id == request.generator_id), None
-        )
-        if spec is None or request.mime_type not in spec.mime_types:
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_CAPABILITY_MISMATCH")
-        if spec.kind == "image":
-            return _artifact_from_bytes(
-                request=request,
-                spec=spec,
-                payload=_png_bytes(request.prompt),
-                filename="generated.png",
-            )
-        return _artifact_from_bytes(
-            request=request,
-            spec=spec,
-            payload=_wav_bytes(request.prompt),
-            filename="generated.wav",
-        )
-
-
-async def _read_limited(response: httpx.Response, maximum: int) -> bytes:
-    declared = response.headers.get("content-length")
-    if declared:
-        try:
-            if int(declared) > maximum:
-                raise ProviderArtifactError("PROVIDER_ARTIFACT_UPSTREAM_TOO_LARGE")
-        except ValueError:
-            pass
-    out = bytearray()
-    async for chunk in response.aiter_bytes():
-        out.extend(chunk)
-        if len(out) > maximum:
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_UPSTREAM_TOO_LARGE")
-    return bytes(out)
-
-
-async def _stream_limited_to_spool(
-    response: httpx.Response, maximum: int
-) -> tuple[tempfile.SpooledTemporaryFile, int, str]:
-    declared = response.headers.get("content-length")
-    if declared:
-        try:
-            if int(declared) > maximum:
-                raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_TOO_LARGE")
-        except ValueError:
-            pass
-    spool = (
-        # lint
-        tempfile.SpooledTemporaryFile(  # ruff: ignore[open-file-with-context-handler]
-            max_size=8 * 1024 * 1024,
-            mode="w+b",
-        )
-    )
-    digest = hashlib.sha256()
-    total = 0
-    try:
-        async for chunk in response.aiter_bytes(chunk_size=_COPY_CHUNK):
-            total += len(chunk)
-            if total > maximum:
-                raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_TOO_LARGE")
-            digest.update(chunk)
-            spool.write(chunk)
-        if total <= 0:
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_INVALID")
-        spool.seek(0)
-        return spool, total, digest.hexdigest()
-    except Exception:
-        spool.close()
-        raise
-
-
-class OpenAIProviderArtifactOutputExecutor:
-    """Official OpenAI GPT Image / Speech API output executor."""
-
-    name = "openai"
-    enabled = True
-
-    _SPECS = (
-        ProviderArtifactGeneratorSpec(
-            id="openai/gpt-image-2",
-            provider="openai",
-            model=_OPENAI_IMAGE_MODEL,
-            kind="image",
-            mime_types=("image/png", "image/jpeg", "image/webp"),
-            max_output_bytes=_IMAGE_MAX_OUTPUT,
-            option_schema={
-                "size": [
-                    "auto",
-                    "1024x1024",
-                    "1536x1024",
-                    "1024x1536",
-                    "2048x2048",
-                    "2048x1152",
-                    "3840x2160",
-                    "2160x3840",
-                ],
-                "quality": ["auto", "low", "medium", "high"],
-            },
-        ),
-        ProviderArtifactGeneratorSpec(
-            id="openai/gpt-4o-mini-tts",
-            provider="openai",
-            model=_OPENAI_TTS_MODEL,
-            kind="audio",
-            mime_types=("audio/mpeg", "audio/wav"),
-            max_output_bytes=_AUDIO_MAX_OUTPUT,
-            option_schema={
-                "voice": [
-                    "alloy",
-                    "ash",
-                    "ballad",
-                    "coral",
-                    "echo",
-                    "fable",
-                    "nova",
-                    "onyx",
-                    "sage",
-                    "shimmer",
-                    "verse",
-                    "marin",
-                    "cedar",
-                ],
-                "instructions": "string",
-            },
-        ),
-    )
-
-    def __init__(
-        self, *, api_key: str, client: httpx.AsyncClient, timeout_seconds: float
-    ) -> None:
-        token = str(api_key or "").strip()
-        if not token:
-            raise ValueError("OpenAI artifact output requires a non-empty API key")
-        self._api_key = token
-        self._client = client
-        self._timeout = max(10.0, min(float(timeout_seconds), 600.0))
-
-    def specs(self) -> Sequence[ProviderArtifactGeneratorSpec]:
-        return self._SPECS
-
-    def _spec(self, request: ProviderArtifactRequest) -> ProviderArtifactGeneratorSpec:
-        spec = next(
-            (row for row in self._SPECS if row.id == request.generator_id), None
-        )
-        if (
-            spec is None
-            or request.mime_type not in spec.mime_types
-            or request.kind != spec.kind
-        ):
-            raise ProviderArtifactError("PROVIDER_ARTIFACT_CAPABILITY_MISMATCH")
-        return spec
-
-    async def generate(
-        self, request: ProviderArtifactRequest
-    ) -> GeneratedProviderArtifact:
-        spec = self._spec(request)
-        headers = {
-            "Authorization": f"Bearer {self._api_key}",
-            "Content-Type": "application/json",
-        }
-        timeout = httpx.Timeout(connect=10.0, read=self._timeout, write=30.0, pool=10.0)
-        if spec.kind == "image":
-            fmt = {"image/png": "png", "image/jpeg": "jpeg", "image/webp": "webp"}[
-                request.mime_type
-            ]
-            payload = {
-                "model": _OPENAI_IMAGE_MODEL,
-                "prompt": request.prompt,
-                "size": request.options.get("size", "auto"),
-                "quality": request.options.get("quality", "auto"),
-                "output_format": fmt,
-            }
-            try:
-                response = await self._client.post(
-                    _OPENAI_IMAGE_URL, headers=headers, json=payload, timeout=timeout
-                )
-            except httpx.RequestError as exc:
-                raise ProviderArtifactError(
-                    "PROVIDER_ARTIFACT_UPSTREAM_UNAVAILABLE"
-                ) from exc
-            try:
-                if response.status_code != 200:  # ruff: ignore[magic-value-comparison]
-                    raise ProviderArtifactError("PROVIDER_ARTIFACT_UPSTREAM_REJECTED")
-                raw = await _read_limited(response, _IMAGE_JSON_MAX)
-            finally:
-                await response.aclose()
-            try:
-                doc = json.loads(raw)
-                encoded = doc["data"][0]["b64_json"]
-                if not isinstance(encoded, str) or not encoded:
-                    raise ValueError
-                # Refuse impossible base64 lengths before decoding into process memory.
-                if len(encoded) > ((_IMAGE_MAX_OUTPUT + 2) // 3) * 4 + 16:
-                    raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_TOO_LARGE")
-                binary = base64.b64decode(encoded, validate=True)
-            except ProviderArtifactError:
-                raise
-            except (
-                KeyError,
-                IndexError,
-                TypeError,
-                ValueError,
-                json.JSONDecodeError,
-            ) as exc:
-                raise ProviderArtifactError("PROVIDER_ARTIFACT_OUTPUT_INVALID") from exc
-            suffix = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp"}[
-                request.mime_type
-            ]
-            return _artifact_from_bytes(
-                request=request,
-                spec=spec,
-                payload=binary,
-                filename="generated" + suffix,
-            )
-
-        response_format = "wav" if request.mime_type == "audio/wav" else "mp3"
-        payload = {
-            "model": _OPENAI_TTS_MODEL,
-            "input": request.prompt,
-            "voice": request.options.get("voice", "marin"),
-            "response_format": response_format,
-        }
-        instructions = request.options.get("instructions", "")
-        if instructions:
-            payload["instructions"] = instructions
-        try:
-            req = self._client.build_request(
-                "POST",
-                _OPENAI_SPEECH_URL,
-                headers=headers,
-                json=payload,
-                timeout=timeout,
-            )
-            response = await self._client.send(req, stream=True)
-        except httpx.RequestError as exc:
-            raise ProviderArtifactError(
-                "PROVIDER_ARTIFACT_UPSTREAM_UNAVAILABLE"
-            ) from exc
-        try:
-            if response.status_code != 200:  # ruff: ignore[magic-value-comparison]
-                raise ProviderArtifactError("PROVIDER_ARTIFACT_UPSTREAM_REJECTED")
-            spool, size, digest = await _stream_limited_to_spool(
-                response, _AUDIO_MAX_OUTPUT
-            )
-        finally:
-            await response.aclose()
-        receipt = build_provider_artifact_receipt_from_digest(
-            request=request,
-            spec=spec,
-            output_size=size,
-            output_sha256=digest,
-        )
-        suffix = ".wav" if request.mime_type == "audio/wav" else ".mp3"
-        return GeneratedProviderArtifact(
-            file=spool, receipt=receipt, filename="generated" + suffix
-        )

_providers/base.py

@@ -1,62 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Provider-neutral resource routing interfaces.
-
-Run 127 defines the provider-routing authority boundary before enabling any
-credential-bearing executor.  Adapters added in later runs must explicitly map each
-verified modality; an unknown modality fails closed instead of being silently
-flattened or dropped.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Protocol, Sequence
-
-try:
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._resource_transport import ResourceUpload
-
-RESOURCE_ROUTES = frozenset({"native", "tool", "extract", "context", "unsupported"})
-
-
-@dataclass(frozen=True)
-class ResourceRoute:
-    resource_id: str
-    route: str
-    reason: str = ""
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def __post_init__(self) -> None:
-        if self.route not in RESOURCE_ROUTES:
-            raise ValueError("invalid resource route")
-
-
-@dataclass(frozen=True)
-class ProviderResourceCapabilities:
-    provider: str
-    model: str
-    modality_routes: dict[str, tuple[str, ...]]
-    max_files: int | None = None
-    max_file_bytes: int | None = None
-    max_total_bytes: int | None = None
-
-    def routes_for(self, modality: str) -> tuple[str, ...]:
-        return tuple(self.modality_routes.get(modality, ("unsupported",)))
-
-
-class ProviderAdapter(Protocol):
-    """Minimal contract every provider adapter must implement."""
-
-    name: str
-
-    def capabilities(self, model: str) -> ProviderResourceCapabilities: ...
-
-    async def route_resources(
-        self, model: str, resources: Sequence[ResourceUpload]
-    ) -> Sequence[ResourceRoute]: ...
-
-    async def close(self) -> None: ...

_providers/custom.py

@@ -1,10 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-"""Explicit custom-backend resource adapter marker."""
-
-from .registry import StaticProviderAdapter
-
-
-class CustomAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("custom", **kwargs)

_providers/executor.py

@@ -1,377 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Credential-neutral provider resource execution lifecycle.
-
-Run 128 defines the state machine every later provider executor must obey.  It
-contains no provider credentials and performs no provider I/O by itself.  The
-important invariant is ownership: once a provider-side resource is created it
-is registered for cleanup immediately, and cleanup is attempted in reverse
-creation order on success, error, timeout, or cancellation.
-"""
-
-from __future__ import annotations
-
-import asyncio
-from dataclasses import dataclass, field
-from typing import Any, AsyncIterator, Protocol, Sequence
-
-from typing_extensions import Self
-
-from .base import ResourceRoute
-
-try:
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._resource_transport import ResourceUpload
-
-
-class ResourceExecutionError(RuntimeError):
-    """A provider resource could not enter a safe executable state."""
-
-
-@dataclass
-class ProviderPrivateResource:
-    """Provider-owned resource handle that must never be serialized publicly."""
-
-    resource_id: str
-    route: str
-    provider: str
-    source_sha256: str
-    source_size: int
-    opaque: Any = None
-    cleanup_required: bool = True
-    released: bool = False
-
-
-@dataclass
-class ResourceExecutionReceipt:
-    """Sanitized chain-of-custody record for one resource lifecycle."""
-
-    resource_id: str
-    provider: str
-    model: str
-    route: str
-    source_sha256: str
-    source_size: int
-    state: str = "prepared"
-    cleanup_required: bool = True
-    cleanup_error: bool = False
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def as_public_dict(self) -> dict[str, Any]:
-        """Return a bounded receipt that contains no provider opaque identifier."""
-        return {
-            "resource_id": self.resource_id,
-            "provider": self.provider,
-            "model": self.model,
-            "route": self.route,
-            "source_sha256": self.source_sha256,
-            "source_size": self.source_size,
-            "state": self.state,
-            "cleanup_required": self.cleanup_required,
-            "cleanup_error": self.cleanup_error,
-            "metadata": dict(self.metadata),
-        }
-
-
-class ProviderResourceExecutor(Protocol):
-    """Provider-specific prepare/release boundary with route-level authority."""
-
-    name: str
-    enabled: bool
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        """Return exact modality routes this executor can perform for *model*."""
-        ...
-
-    async def prepare(
-        self,
-        *,
-        model: str,
-        route: ResourceRoute,
-        upload: ResourceUpload,
-    ) -> ProviderPrivateResource: ...
-
-    async def release(self, handle: ProviderPrivateResource) -> None: ...
-
-
-class ProviderChatExecutor(ProviderResourceExecutor, Protocol):
-    """
-    Executable provider boundary for one prepared resource chat request.
-
-    Provider planning and temporary-resource ownership remain generic.  Only an
-    executor registered in the separate execution registry may implement this
-    credential-bearing boundary.  ``chat`` and ``upstream`` deliberately stay
-    provider-neutral here so the common proxy lifecycle does not depend on one
-    SDK's public types.
-    """
-
-    async def open_chat(
-        self,
-        *,
-        chat: Any,
-        handles: Sequence[ProviderPrivateResource],
-    ) -> Any: ...
-
-    async def buffered_chat_response(self, upstream: Any, *, maximum: int) -> dict: ...
-
-    def chat_sse(self, upstream: Any, *, maximum: int) -> AsyncIterator[bytes]: ...
-
-
-@dataclass
-class PendingProviderExecutor:
-    """Explicit non-executor used until a credential-bearing adapter is enabled."""
-
-    name: str
-    enabled: bool = False
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        del model
-        return {}
-
-    async def prepare(
-        self,
-        *,
-        model: str,
-        route: ResourceRoute,
-        upload: ResourceUpload,
-    ) -> ProviderPrivateResource:
-        del model, route, upload
-        raise ResourceExecutionError(f"{self.name} resource executor is not enabled")
-
-    async def release(self, handle: ProviderPrivateResource) -> None:
-        del handle
-
-
-class ProviderExecutorRegistry:
-    """Execution registry separate from provider capability/route planning."""
-
-    def __init__(self, names: Sequence[str] = ()) -> None:
-        names = [str(name).strip().lower() for name in names]
-        self._executors: dict[str, ProviderResourceExecutor] = {
-            name: PendingProviderExecutor(name) for name in names if str(name).strip()
-        }
-
-    def register(self, name: str, executor: ProviderResourceExecutor) -> None:
-        key = str(name or "").strip().lower()
-        if not key or key != str(executor.name or "").strip().lower():
-            raise ValueError("executor registry name mismatch")
-        self._executors[key] = executor
-
-    def unregister(self, name: str) -> None:
-        """Return one provider to explicit plan-only state."""
-        key = str(name or "").strip().lower()
-        if key:
-            self._executors[key] = PendingProviderExecutor(key)
-
-    def get(self, name: str) -> ProviderResourceExecutor:
-        key = str(name or "custom").strip().lower() or "custom"
-        return self._executors.get(key, PendingProviderExecutor(key))
-
-    def execution_state(self, name: str) -> str:
-        return "enabled" if bool(self.get(name).enabled) else "plan-only"
-
-
-class ResourceExecutionSession:
-    """Sequential prepare + shielded LIFO cleanup for one provider request."""
-
-    def __init__(
-        self,
-        *,
-        provider: str,
-        model: str,
-        executor: ProviderResourceExecutor,
-        routes: Sequence[ResourceRoute],
-    ) -> None:
-        self.provider = str(provider or "").strip().lower()
-        self.model = str(model or "")
-        self.executor = executor
-        self.routes = tuple(routes)
-        self._handles: list[ProviderPrivateResource] = []
-        self._receipts: list[ResourceExecutionReceipt] = []
-        self._closed = False
-        self._close_lock = asyncio.Lock()
-
-    @property
-    def receipts(self) -> tuple[ResourceExecutionReceipt, ...]:
-        return tuple(self._receipts)
-
-    @property
-    def private_handles(self) -> tuple[ProviderPrivateResource, ...]:
-        """
-        Return request-private provider handles for the in-process executor only.
-
-        These handles are intentionally never exposed by receipts, health, logs,
-        persistence, or browser responses.  Provider execution consumes them only
-        after :meth:`prepare` has validated the full upload/route identity.
-        """
-        return tuple(self._handles)
-
-    def public_receipts(self) -> tuple[dict[str, Any], ...]:
-        return tuple(row.as_public_dict() for row in self._receipts)
-
-    def _validate_plan(
-        self, uploads: Sequence[ResourceUpload]
-    ) -> dict[str, ResourceUpload]:
-        if not bool(getattr(self.executor, "enabled", False)):
-            raise ResourceExecutionError(
-                f"{self.provider} resource executor is not enabled"
-            )
-        by_id: dict[str, ResourceUpload] = {}
-        for upload in uploads:
-            rid = upload.verified.id
-            if rid in by_id:
-                raise ResourceExecutionError("duplicate resource upload id")
-            by_id[rid] = upload
-        route_ids: set[str] = set()
-        for route in self.routes:
-            if route.resource_id in route_ids:
-                raise ResourceExecutionError("duplicate resource route id")
-            route_ids.add(route.resource_id)
-            if route.route == "unsupported":
-                raise ResourceExecutionError("resource plan contains unsupported route")
-        if route_ids != set(by_id):
-            raise ResourceExecutionError("resource plan/upload ids do not match")
-        return by_id
-
-    def _register_handle(
-        self,
-        *,
-        route: ResourceRoute,
-        upload: ResourceUpload,
-        handle: ProviderPrivateResource,
-    ) -> None:
-        """
-        Validate and register one private handle before it can be used.
-
-        Batch-capable executors may create shared provider resources (for
-        example one retrieval store for many files).  The common lifecycle
-        still validates every returned per-resource handle against the exact
-        verified upload and route so batch preparation cannot weaken identity
-        or receipt authority.
-        """
-        if (
-            handle.resource_id != route.resource_id
-            or handle.route != route.route
-            or handle.provider != self.provider
-            or handle.source_sha256 != upload.verified.sha256
-            or int(handle.source_size) != int(upload.verified.actual_size)
-        ):
-            # Register first so even a malformed provider response is released
-            # before the validation error escapes.
-            self._handles.append(handle)
-            raise ResourceExecutionError(
-                "provider resource handle failed identity validation"
-            )
-        self._handles.append(handle)
-        self._receipts.append(
-            ResourceExecutionReceipt(
-                resource_id=route.resource_id,
-                provider=self.provider,
-                model=self.model,
-                route=route.route,
-                source_sha256=upload.verified.sha256,
-                source_size=upload.verified.actual_size,
-                cleanup_required=bool(handle.cleanup_required),
-                metadata={
-                    "modality": route.metadata.get("modality", ""),
-                    "intent": route.metadata.get("intent", ""),
-                },
-            )
-        )
-
-    async def prepare(
-        self, uploads: Sequence[ResourceUpload]
-    ) -> tuple[ResourceExecutionReceipt, ...]:
-        by_id = self._validate_plan(uploads)
-        ordered_uploads = tuple(by_id[route.resource_id] for route in self.routes)
-        try:
-            prepare_many = getattr(self.executor, "prepare_many", None)
-            if callable(prepare_many):
-                # A batch executor owns rollback for provider objects created
-                # before this method returns.  Once returned, the common
-                # session immediately registers every handle and owns cleanup.
-                handles = tuple(
-                    await prepare_many(
-                        model=self.model,
-                        routes=self.routes,
-                        uploads=ordered_uploads,
-                    )
-                )
-                if len(handles) != len(self.routes):
-                    # Returned handles are the only provider cleanup authority
-                    # available to the session. Register all of them so a bad
-                    # batch count cannot silently leak those that are usable.
-                    self._handles.extend(handles)
-                    raise ResourceExecutionError(
-                        "provider batch prepare returned the wrong handle count"
-                    )
-                for route, upload, handle in zip(self.routes, ordered_uploads, handles):
-                    self._register_handle(route=route, upload=upload, handle=handle)
-            else:
-                for route, upload in zip(self.routes, ordered_uploads):
-                    handle = await self.executor.prepare(
-                        model=self.model,
-                        route=route,
-                        upload=upload,
-                    )
-                    self._register_handle(route=route, upload=upload, handle=handle)
-            return self.receipts
-        except BaseException:
-            await self.close_shielded()
-            raise
-
-    async def _release_all(self) -> None:
-        # Receipts and handles are aligned only for handles that passed identity
-        # validation. A malformed last handle may therefore have no receipt.
-        receipt_by_id = {row.resource_id: row for row in self._receipts}
-        for handle in reversed(self._handles):
-            if handle.released or not handle.cleanup_required:
-                handle.released = True
-                receipt = receipt_by_id.get(handle.resource_id)
-                if receipt is not None:
-                    receipt.state = "released"
-                continue
-            try:
-                await self.executor.release(handle)
-            except Exception:  # noqa: BLE001
-                receipt = receipt_by_id.get(handle.resource_id)
-                if receipt is not None:
-                    receipt.state = "cleanup_failed"
-                    receipt.cleanup_error = True
-            else:
-                handle.released = True
-                receipt = receipt_by_id.get(handle.resource_id)
-                if receipt is not None:
-                    receipt.state = "released"
-
-    async def close(self) -> tuple[ResourceExecutionReceipt, ...]:
-        async with self._close_lock:
-            if self._closed:
-                return self.receipts
-            await self._release_all()
-            self._closed = True
-            return self.receipts
-
-    async def close_shielded(self) -> tuple[ResourceExecutionReceipt, ...]:
-        """Finish cleanup even when the caller task is being cancelled."""
-        task = asyncio.create_task(self.close())
-        try:
-            return await asyncio.shield(task)
-        except asyncio.CancelledError:
-            # Do not abandon provider cleanup. Preserve cancellation only after
-            # the cleanup task has reached its terminal state.
-            try:
-                await task
-            finally:
-                raise
-
-    async def __aenter__(self) -> Self:
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb) -> bool:
-        del exc_type, exc, tb
-        await self.close_shielded()
-        return False

_providers/gemini.py

@@ -1,1167 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Gemini Files + Interactions first-class resource executor.
-
-Verified browser resources are uploaded byte-for-byte through Gemini's provider
-facilities.  Provider names/URIs/store names are request-private capabilities,
-never public receipts.  Image/GIF/audio/video/PDF use native Files + Interactions
-content blocks; reviewed text/ZIP/XLS/XLSX resources may use one request-scoped
-File Search store with mandatory cleanup and route-specific MIME/size limits.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import binascii
-import json
-import re
-from collections.abc import AsyncIterator, Sequence
-from urllib.parse import quote, urlparse
-
-import httpx
-
-from .executor import ProviderPrivateResource, ResourceExecutionError
-from .policy import (
-    gemini_file_search_supported_model,
-    gemini_native_media_supported_model,
-)
-from .registry import StaticProviderAdapter
-
-try:
-    from .._utils._chat_contract import ChatRequest, build_upstream_payload
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._chat_contract import ChatRequest, build_upstream_payload
-    from _utils._resource_transport import ResourceUpload
-
-_GEMINI_BASE = "https://generativelanguage.googleapis.com"
-_GEMINI_INTERACTIONS_URL = (
-    "https://generativelanguage.googleapis.com/v1beta/interactions"
-)
-_UPLOAD_CHUNK_BYTES = 1024 * 1024
-_MAX_PDF_BYTES = 50 * 1024 * 1024
-_FILE_SEARCH_MAX_BYTES = 100 * 1024 * 1024
-_MAX_SSE_EVENT_BYTES = 1024 * 1024
-_FILE_NAME_RE = re.compile(r"^files/[A-Za-z0-9._~-]{1,240}$")
-_FILE_SEARCH_STORE_RE = re.compile(
-    r"^fileSearchStores/[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$"
-)
-_FILE_SEARCH_OPERATION_RE = re.compile(
-    r"^fileSearchStores/[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?/upload/operations/[A-Za-z0-9._~-]{1,240}$"
-)
-_FILE_SEARCH_MIMES = {
-    "archive": {"application/zip"},
-    "data": {
-        "application/vnd.ms-excel",
-        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    },
-}
-_NATIVE_MIMES = {
-    "image": {
-        "image/png",
-        "image/jpeg",
-        "image/webp",
-        "image/heic",
-        "image/heif",
-        "image/bmp",
-        "image/tiff",
-    },
-    "animated_image": {"image/gif"},
-    "audio": {
-        "audio/wav",
-        "audio/mp3",
-        "audio/aiff",
-        "audio/aac",
-        "audio/ogg",
-        "audio/flac",
-        "audio/mpeg",
-        "audio/m4a",
-        "audio/l16",
-        "audio/opus",
-        "audio/alaw",
-        "audio/mulaw",
-        "audio/webm",
-    },
-    "video": {
-        "video/mp4",
-        "video/mpeg",
-        "video/mpg",
-        "video/mov",
-        "video/avi",
-        "video/x-flv",
-        "video/webm",
-        "video/wmv",
-        "video/3gpp",
-    },
-    "document": {"application/pdf"},
-}
-
-_MIME_ALIASES = {
-    "image/jpg": "image/jpeg",
-    "video/quicktime": "video/mov",
-    "video/x-msvideo": "video/avi",
-    "video/x-ms-wmv": "video/wmv",
-    "audio/x-wav": "audio/wav",
-    "audio/x-aiff": "audio/aiff",
-    "audio/x-flac": "audio/flac",
-    "audio/x-m4a": "audio/m4a",
-    "audio/mp4": "audio/m4a",
-}
-
-
-def _gemini_mime(upload: ResourceUpload) -> str:
-    raw = str(upload.verified.detected_mime or "application/octet-stream").lower()
-    return _MIME_ALIASES.get(raw, raw)
-
-
-class GeminiAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("gemini", **kwargs)
-
-
-def _validated_gemini_base(value: str) -> str:
-    raw = str(value or _GEMINI_BASE).rstrip("/")
-    parsed = urlparse(raw)
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "generativelanguage.googleapis.com"
-        or parsed.port not in {None, 443}
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.query
-        or parsed.fragment
-        or parsed.path not in {"", "/"}
-    ):
-        raise ValueError("Gemini executor requires the official HTTPS API origin")
-    return _GEMINI_BASE
-
-
-def official_gemini_interactions_backend(value: str) -> bool:
-    raw = str(value or "").strip().rstrip("/")
-    try:
-        parsed = urlparse(raw)
-    except ValueError:
-        return False
-    return bool(
-        parsed.scheme == "https"
-        and parsed.hostname == "generativelanguage.googleapis.com"
-        and parsed.port in {None, 443}
-        and parsed.username is None
-        and parsed.password is None
-        and not parsed.query
-        and not parsed.fragment
-        and parsed.path.rstrip("/") == "/v1beta/interactions"
-        and raw == _GEMINI_INTERACTIONS_URL
-    )
-
-
-def _validated_upload_url(value: str) -> str:
-    raw = str(value or "").strip()
-    if len(raw) > 4096 or any(  # ruff: ignore[magic-value-comparison]
-        ord(ch) < 32  # ruff: ignore[magic-value-comparison]
-        or ord(ch) == 127  # ruff: ignore[magic-value-comparison]
-        for ch in raw
-    ):
-        raise ResourceExecutionError("Gemini resumable upload URL was invalid")
-    try:
-        parsed = urlparse(raw)
-    except ValueError as exc:
-        raise ResourceExecutionError("Gemini resumable upload URL was invalid") from exc
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "generativelanguage.googleapis.com"
-        or parsed.port not in {None, 443}
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.fragment
-        or not parsed.path.startswith("/upload/v1beta/files")
-    ):
-        raise ResourceExecutionError("Gemini resumable upload URL was invalid")
-    return raw
-
-
-def _safe_file_name(value: object) -> str:
-    name = str(value or "").strip()
-    if not _FILE_NAME_RE.fullmatch(name):
-        raise ResourceExecutionError("Gemini Files returned an invalid file name")
-    return name
-
-
-def _safe_file_uri(value: object) -> str:
-    raw = str(value or "").strip()
-    if len(raw) > 4096 or any(  # ruff: ignore[magic-value-comparison]
-        ord(ch) < 32  # ruff: ignore[magic-value-comparison]
-        or ord(ch) == 127  # ruff: ignore[magic-value-comparison]
-        for ch in raw
-    ):
-        raise ResourceExecutionError("Gemini Files returned an invalid file URI")
-    try:
-        parsed = urlparse(raw)
-    except ValueError as exc:
-        raise ResourceExecutionError(
-            "Gemini Files returned an invalid file URI"
-        ) from exc
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "generativelanguage.googleapis.com"
-        or parsed.port not in {None, 443}
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.query
-        or parsed.fragment
-        or not parsed.path.startswith("/v1beta/files/")
-    ):
-        raise ResourceExecutionError("Gemini Files returned an invalid file URI")
-    return raw
-
-
-def _native_opaque(handle: ProviderPrivateResource) -> dict:
-    data = handle.opaque if isinstance(handle.opaque, dict) else {}
-    name = _safe_file_name(data.get("file_name"))
-    uri = _safe_file_uri(data.get("uri"))
-    return {**data, "file_name": name, "uri": uri}
-
-
-def _safe_store_name(value: object) -> str:
-    name = str(value or "").strip()
-    if not _FILE_SEARCH_STORE_RE.fullmatch(name):
-        raise ResourceExecutionError(
-            "Gemini File Search returned an invalid store name"
-        )
-    return name
-
-
-def _safe_operation_name(value: object, store_name: str) -> str:
-    name = str(value or "").strip()
-    if not _FILE_SEARCH_OPERATION_RE.fullmatch(name) or not name.startswith(
-        store_name + "/upload/operations/"
-    ):
-        raise ResourceExecutionError(
-            "Gemini File Search returned an invalid operation name"
-        )
-    return name
-
-
-def _validated_file_search_upload_url(value: str, store_name: str) -> str:
-    raw = str(value or "").strip()
-    if len(raw) > 4096 or any(  # ruff: ignore[magic-value-comparison]
-        ord(ch) < 32  # ruff: ignore[magic-value-comparison]
-        or ord(ch) == 127  # ruff: ignore[magic-value-comparison]
-        for ch in raw
-    ):
-        raise ResourceExecutionError("Gemini File Search upload URL was invalid")
-    try:
-        parsed = urlparse(raw)
-    except ValueError as exc:
-        raise ResourceExecutionError(
-            "Gemini File Search upload URL was invalid"
-        ) from exc
-    expected = "/upload/v1beta/" + store_name + ":uploadToFileSearchStore"
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "generativelanguage.googleapis.com"
-        or parsed.port not in {None, 443}
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.fragment
-        or parsed.path != expected
-    ):
-        raise ResourceExecutionError("Gemini File Search upload URL was invalid")
-    return raw
-
-
-def _tool_opaque(handle: ProviderPrivateResource) -> dict:
-    data = handle.opaque if isinstance(handle.opaque, dict) else {}
-    return {**data, "store_name": _safe_store_name(data.get("store_name"))}
-
-
-def _file_search_mime(upload: ResourceUpload) -> str:
-    modality = str(upload.verified.detected_modality or "")
-    raw = str(upload.verified.detected_mime or "application/octet-stream").lower()
-    if modality == "text":
-        if raw.startswith("text/") or raw in {"application/json", "application/xml"}:
-            return raw
-        # The verifier already classified the resource as text. Normalizing
-        # uncommon textual application/* labels to text/plain changes only
-        # provider metadata, never the source bytes.
-        return "text/plain"
-    return raw
-
-
-def _provider_hash_hex(value: object) -> str:
-    raw = str(value or "").strip()
-    if not raw:
-        return ""
-    try:
-        decoded = base64.b64decode(raw, validate=True)
-    except (ValueError, binascii.Error) as exc:
-        raise ResourceExecutionError(
-            "Gemini Files returned invalid SHA-256 metadata"
-        ) from exc
-    if len(decoded) != 32:  # ruff: ignore[magic-value-comparison]
-        raise ResourceExecutionError("Gemini Files returned invalid SHA-256 metadata")
-    return decoded.hex()
-
-
-def _file_metadata(payload: object) -> dict:
-    if isinstance(payload, dict) and isinstance(payload.get("file"), dict):
-        return payload["file"]
-    if isinstance(payload, dict):
-        return payload
-    raise ResourceExecutionError("Gemini Files returned invalid metadata")
-
-
-def _response_text(payload: object) -> str:
-    if not isinstance(payload, dict):
-        raise ResourceExecutionError("Gemini Interactions returned invalid metadata")
-    status = str(payload.get("status", "") or "")
-    if status != "completed" or payload.get("error"):
-        raise ResourceExecutionError(
-            "Gemini Interactions did not complete successfully"
-        )
-    pieces: list[str] = []
-    steps = payload.get("steps")
-    if isinstance(steps, list):
-        for step in steps:
-            if not isinstance(step, dict) or step.get("type") != "model_output":
-                continue
-            content = step.get("content")
-            if not isinstance(content, list):
-                continue
-            for row in content:
-                if (
-                    isinstance(row, dict)
-                    and row.get("type") == "text"
-                    and isinstance(row.get("text"), str)
-                ):
-                    pieces.append(row["text"])
-    text = "".join(pieces)
-    if not text:
-        raise ResourceExecutionError("Gemini Interactions returned no assistant text")
-    return text
-
-
-class GeminiResourceExecutor:
-    """Upload verified native media to Gemini Files and execute Interactions."""
-
-    name = "gemini"
-    enabled = True
-
-    def __init__(
-        self,
-        *,
-        api_key: str,
-        client: httpx.AsyncClient,
-        base_url: str = _GEMINI_BASE,
-        response_timeout_seconds: float = 600.0,
-        processing_timeout_seconds: float = 300.0,
-        poll_interval_seconds: float = 1.0,
-    ) -> None:
-        key = str(api_key or "").strip()
-        if not key:
-            raise ValueError("Gemini API key is required")
-        self._api_key = key
-        self._client = client
-        self._base = _validated_gemini_base(base_url)
-        self._response_timeout = httpx.Timeout(
-            connect=20.0,
-            read=max(30.0, min(float(response_timeout_seconds), 1800.0)),
-            write=180.0,
-            pool=20.0,
-        )
-        self._processing_timeout = max(
-            1.0, min(float(processing_timeout_seconds), 900.0)
-        )
-        self._poll_interval = max(0.05, min(float(poll_interval_seconds), 5.0))
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        routes: dict[str, tuple[str, ...]] = {}
-        if gemini_native_media_supported_model(model):
-            routes.update(
-                {
-                    "image": ("native",),
-                    "animated_image": ("native",),
-                    "audio": ("native",),
-                    "video": ("native",),
-                    "document": ("native",),
-                }
-            )
-        if gemini_file_search_supported_model(model):
-            routes.update(
-                {
-                    "text": ("tool",),
-                    "archive": ("tool",),
-                    "data": ("tool",),
-                }
-            )
-        return routes
-
-    def route_constraints(self, model: str) -> dict[str, dict[str, dict]]:
-        """
-        Return browser-visible limits for exact executable routes.
-
-        Limits are route-specific because Gemini native media and File Search
-        have different provider ceilings and MIME vocabularies.  This data is
-        non-secret and is re-checked server-side before provider I/O.
-        """
-        constraints: dict[str, dict[str, dict]] = {}
-        if gemini_native_media_supported_model(model):
-            constraints["document"] = {
-                "native": {
-                    "max_file_bytes": _MAX_PDF_BYTES,
-                    "mime_types": ["application/pdf"],
-                }
-            }
-        if gemini_file_search_supported_model(model):
-            constraints["text"] = {"tool": {"max_file_bytes": _FILE_SEARCH_MAX_BYTES}}
-            constraints["archive"] = {
-                "tool": {
-                    "max_file_bytes": _FILE_SEARCH_MAX_BYTES,
-                    "mime_types": sorted(_FILE_SEARCH_MIMES["archive"]),
-                }
-            }
-            constraints["data"] = {
-                "tool": {
-                    "max_file_bytes": _FILE_SEARCH_MAX_BYTES,
-                    "mime_types": sorted(_FILE_SEARCH_MIMES["data"]),
-                }
-            }
-        return constraints
-
-    def _headers(self) -> dict[str, str]:
-        return {"x-goog-api-key": self._api_key, "Accept": "application/json"}
-
-    async def _raw_body(self, upload: ResourceUpload):
-        await upload.upload.seek(0)
-        try:
-            while True:
-                chunk = await upload.upload.read(_UPLOAD_CHUNK_BYTES)
-                if not chunk:
-                    break
-                yield chunk
-        finally:
-            await upload.upload.seek(0)
-
-    def _validate_metadata(
-        self, meta: dict, upload: ResourceUpload
-    ) -> tuple[str, str, str]:
-        verified = upload.verified
-        name = _safe_file_name(meta.get("name"))
-        uri = _safe_file_uri(meta.get("uri"))
-        state = str(meta.get("state", "") or "").upper()
-        size = meta.get("sizeBytes", meta.get("size_bytes"))
-        if size is not None:
-            try:
-                if int(size) != int(verified.actual_size):
-                    raise ResourceExecutionError(
-                        "Gemini Files size did not match source bytes"
-                    )
-            except (TypeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini Files returned invalid size metadata"
-                ) from exc
-        provider_hash = _provider_hash_hex(
-            meta.get("sha256Hash", meta.get("sha256_hash"))
-        )
-        if provider_hash and provider_hash != verified.sha256:
-            raise ResourceExecutionError(
-                "Gemini Files SHA-256 did not match source bytes"
-            )
-        returned_mime = str(
-            meta.get("mimeType", meta.get("mime_type", "")) or ""
-        ).lower()
-        expected_mime = _gemini_mime(upload)
-        if returned_mime and returned_mime != expected_mime:
-            raise ResourceExecutionError(
-                "Gemini Files MIME metadata did not match verified bytes"
-            )
-        return name, uri, state
-
-    async def _delete_name(self, name: str) -> None:
-        safe = _safe_file_name(name)
-        try:
-            response = await self._client.delete(
-                f"{self._base}/v1beta/{quote(safe, safe='/')}", headers=self._headers()
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini temporary file cleanup failed"
-            ) from exc
-        if response.status_code == 404:  # ruff: ignore[magic-value-comparison]
-            return
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError("Gemini temporary file cleanup was rejected")
-
-    async def _wait_active(
-        self, *, name: str, upload: ResourceUpload, initial: dict
-    ) -> dict:
-        meta = initial
-        deadline = asyncio.get_running_loop().time() + self._processing_timeout
-        while True:
-            got_name, _uri, state = self._validate_metadata(meta, upload)
-            if got_name != name:
-                raise ResourceExecutionError(
-                    "Gemini Files identity changed while processing"
-                )
-            if state == "ACTIVE":
-                return meta
-            if state == "FAILED":
-                raise ResourceExecutionError("Gemini Files processing failed")
-            if state not in {"PROCESSING", "STATE_UNSPECIFIED", ""}:
-                raise ResourceExecutionError(
-                    "Gemini Files returned an unexpected processing state"
-                )
-            if asyncio.get_running_loop().time() >= deadline:
-                raise ResourceExecutionError("Gemini Files processing timed out")
-            await asyncio.sleep(self._poll_interval)
-            try:
-                response = await self._client.get(
-                    f"{self._base}/v1beta/{quote(name, safe='/')}",
-                    headers=self._headers(),
-                )
-            except (httpx.HTTPError, OSError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini Files processing check failed"
-                ) from exc
-            if (
-                response.status_code < 200  # ruff: ignore[magic-value-comparison]
-                or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-            ):
-                raise ResourceExecutionError(
-                    "Gemini Files processing check was rejected"
-                )
-            try:
-                meta = _file_metadata(response.json())
-            except (json.JSONDecodeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini Files processing metadata was invalid"
-                ) from exc
-
-    async def _create_file_search_store(self) -> str:
-        payload = {
-            "displayName": "scikit-plots-ephemeral",
-            "embeddingModel": "models/gemini-embedding-2",
-        }
-        headers = self._headers()
-        headers["Content-Type"] = "application/json"
-        try:
-            response = await self._client.post(
-                f"{self._base}/v1beta/fileSearchStores",
-                headers=headers,
-                content=json.dumps(
-                    payload, ensure_ascii=False, separators=(",", ":")
-                ).encode("utf-8"),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search store creation failed"
-            ) from exc
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError(
-                "Gemini File Search store creation was rejected"
-            )
-        try:
-            data = response.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search store metadata was invalid"
-            ) from exc
-        if not isinstance(data, dict):
-            raise ResourceExecutionError(
-                "Gemini File Search store metadata was invalid"
-            )
-        return _safe_store_name(data.get("name"))
-
-    async def _delete_store(self, store_name: str) -> None:
-        safe = _safe_store_name(store_name)
-        try:
-            response = await self._client.delete(
-                f"{self._base}/v1beta/{quote(safe, safe='/')}?force=true",
-                headers=self._headers(),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search store cleanup failed"
-            ) from exc
-        if response.status_code == 404:  # ruff: ignore[magic-value-comparison]
-            return
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError(
-                "Gemini File Search store cleanup was rejected"
-            )
-
-    async def _wait_file_search_operation(
-        self, *, store_name: str, payload: object
-    ) -> None:
-        if not isinstance(payload, dict):
-            raise ResourceExecutionError(
-                "Gemini File Search upload returned invalid operation metadata"
-            )
-        operation_name = _safe_operation_name(payload.get("name"), store_name)
-        operation = payload
-        deadline = asyncio.get_running_loop().time() + self._processing_timeout
-        while True:
-            if operation.get("error"):
-                raise ResourceExecutionError("Gemini File Search indexing failed")
-            if operation.get("done") is True:
-                return
-            if asyncio.get_running_loop().time() >= deadline:
-                raise ResourceExecutionError("Gemini File Search indexing timed out")
-            await asyncio.sleep(self._poll_interval)
-            try:
-                response = await self._client.get(
-                    f"{self._base}/v1beta/{quote(operation_name, safe='/')}",
-                    headers=self._headers(),
-                )
-            except (httpx.HTTPError, OSError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini File Search indexing check failed"
-                ) from exc
-            if (
-                response.status_code < 200  # ruff: ignore[magic-value-comparison]
-                or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-            ):
-                raise ResourceExecutionError(
-                    "Gemini File Search indexing check was rejected"
-                )
-            try:
-                operation = response.json()
-            except (json.JSONDecodeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini File Search operation metadata was invalid"
-                ) from exc
-            if (
-                not isinstance(operation, dict)
-                or _safe_operation_name(operation.get("name"), store_name)
-                != operation_name
-            ):
-                raise ResourceExecutionError(
-                    "Gemini File Search operation identity changed"
-                )
-
-    async def _upload_to_file_search_store(
-        self, *, store_name: str, upload: ResourceUpload
-    ) -> None:
-        verified = upload.verified
-        modality = str(verified.detected_modality or "")
-        mime = _file_search_mime(upload)
-        if int(verified.actual_size) > _FILE_SEARCH_MAX_BYTES:
-            raise ResourceExecutionError(
-                "Gemini File Search resource exceeds the 100 MB document limit"
-            )
-        if modality == "archive":
-            if mime not in _FILE_SEARCH_MIMES["archive"]:
-                raise ResourceExecutionError(
-                    "Gemini File Search does not support this archive MIME type"
-                )
-        elif modality == "data":
-            if mime not in _FILE_SEARCH_MIMES["data"]:
-                raise ResourceExecutionError(
-                    "Gemini File Search does not support this data MIME type"
-                )
-        elif modality != "text":
-            raise ResourceExecutionError(
-                "Gemini File Search does not support this resource modality"
-            )
-
-        safe_store = _safe_store_name(store_name)
-        start_headers = self._headers()
-        start_headers.update(
-            {
-                "X-Goog-Upload-Protocol": "resumable",
-                "X-Goog-Upload-Command": "start",
-                "X-Goog-Upload-Header-Content-Length": str(verified.actual_size),
-                "X-Goog-Upload-Header-Content-Type": mime,
-                "Content-Type": "application/json",
-            }
-        )
-        display_name = str(verified.name or "resource")[:512]
-        try:
-            start = await self._client.post(
-                f"{self._base}/upload/v1beta/{quote(safe_store, safe='/')}:uploadToFileSearchStore",
-                headers=start_headers,
-                content=json.dumps(
-                    {"displayName": display_name},
-                    ensure_ascii=False,
-                    separators=(",", ":"),
-                ).encode("utf-8"),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search resumable upload could not start"
-            ) from exc
-        if (
-            start.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or start.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError(
-                "Gemini File Search resumable upload start was rejected"
-            )
-        upload_url = _validated_file_search_upload_url(
-            start.headers.get("x-goog-upload-url", ""), safe_store
-        )
-        try:
-            finish = await self._client.post(
-                upload_url,
-                headers={
-                    "Content-Length": str(verified.actual_size),
-                    "X-Goog-Upload-Offset": "0",
-                    "X-Goog-Upload-Command": "upload, finalize",
-                    "Content-Type": mime,
-                },
-                content=self._raw_body(upload),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search resource upload failed"
-            ) from exc
-        if (
-            finish.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or finish.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError(
-                "Gemini File Search resource upload was rejected"
-            )
-        try:
-            operation = finish.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Gemini File Search upload returned invalid operation metadata"
-            ) from exc
-        await self._wait_file_search_operation(store_name=safe_store, payload=operation)
-
-    async def prepare_many(  # ruff: ignore[too-many-branches]
-        self, *, model: str, routes: Sequence, uploads: Sequence[ResourceUpload]
-    ):
-        if len(routes) != len(uploads):
-            raise ResourceExecutionError(
-                "Gemini batch prepare route/upload count mismatch"
-            )
-        pairs = tuple(zip(routes, uploads))
-        tool_pairs = []
-        for route, upload in pairs:
-            if route.resource_id != upload.verified.id:
-                raise ResourceExecutionError(
-                    "Gemini batch prepare resource identity mismatch"
-                )
-            modality = str(upload.verified.detected_modality or "")
-            allowed = self.executable_routes(model).get(modality, ())
-            if route.route not in allowed:
-                raise ResourceExecutionError(
-                    "Gemini executor does not implement this modality/route"
-                )
-            if route.route == "tool":
-                # Validate provider limits/MIME before any provider object is
-                # created. The upload helper repeats these checks defensively.
-                mime = _file_search_mime(upload)
-                if int(upload.verified.actual_size) > _FILE_SEARCH_MAX_BYTES:
-                    raise ResourceExecutionError(
-                        "Gemini File Search resource exceeds the 100 MB document limit"
-                    )
-                if modality == "archive" and mime not in _FILE_SEARCH_MIMES["archive"]:
-                    raise ResourceExecutionError(
-                        "Gemini File Search does not support this archive MIME type"
-                    )
-                if modality == "data" and mime not in _FILE_SEARCH_MIMES["data"]:
-                    raise ResourceExecutionError(
-                        "Gemini File Search does not support this data MIME type"
-                    )
-                tool_pairs.append((route, upload))
-
-        store_name = ""
-        native_handles: list[ProviderPrivateResource] = []
-        output: dict[str, ProviderPrivateResource] = {}
-        try:
-            if tool_pairs:
-                if not gemini_file_search_supported_model(model):
-                    raise ResourceExecutionError(
-                        "Gemini model does not support File Search"
-                    )
-                store_name = await self._create_file_search_store()
-                for _route, upload in tool_pairs:
-                    await self._upload_to_file_search_store(
-                        store_name=store_name, upload=upload
-                    )
-
-            owner_id = tool_pairs[0][0].resource_id if tool_pairs else ""
-            for route, upload in pairs:
-                if route.route == "native":
-                    handle = await self.prepare(model=model, route=route, upload=upload)
-                    native_handles.append(handle)
-                    output[route.resource_id] = handle
-                else:
-                    output[route.resource_id] = ProviderPrivateResource(
-                        resource_id=upload.verified.id,
-                        route="tool",
-                        provider=self.name,
-                        source_sha256=upload.verified.sha256,
-                        source_size=upload.verified.actual_size,
-                        opaque={
-                            "store_name": store_name,
-                            "modality": upload.verified.detected_modality,
-                            "mime": _file_search_mime(upload),
-                            "name": upload.verified.name,
-                        },
-                        cleanup_required=(route.resource_id == owner_id),
-                    )
-            return tuple(output[route.resource_id] for route, _upload in pairs)
-        except BaseException:
-            for handle in reversed(native_handles):
-                try:  # ruff: ignore[suppressible-exception]
-                    await asyncio.shield(self.release(handle))
-                except Exception:  # ruff: ignore[blind-except]
-                    pass
-            if store_name:
-                try:  # ruff: ignore[suppressible-exception]
-                    await asyncio.shield(self._delete_store(store_name))
-                except Exception:  # ruff: ignore[blind-except]
-                    pass
-            raise
-
-    async def prepare(  # ruff: ignore[too-many-branches]
-        self, *, model: str, route, upload: ResourceUpload
-    ) -> ProviderPrivateResource:
-        verified = upload.verified
-        modality = verified.detected_modality
-        mime = _gemini_mime(upload)
-        if route.resource_id != verified.id or route.route != "native":
-            raise ResourceExecutionError(
-                "Gemini executor received an invalid resource route"
-            )
-        if modality not in self.executable_routes(model):
-            raise ResourceExecutionError(
-                "Gemini native route does not support this modality"
-            )
-        if mime not in _NATIVE_MIMES.get(modality, set()):
-            raise ResourceExecutionError(
-                "Gemini native route does not support this MIME type"
-            )
-        if (
-            modality == "document"
-            and mime == "application/pdf"
-            and int(verified.actual_size) > _MAX_PDF_BYTES
-        ):
-            raise ResourceExecutionError(
-                "Gemini PDF exceeds the bounded 50 MB provider limit"
-            )
-
-        start_headers = self._headers()
-        start_headers.update(
-            {
-                "X-Goog-Upload-Protocol": "resumable",
-                "X-Goog-Upload-Command": "start",
-                "X-Goog-Upload-Header-Content-Length": str(verified.actual_size),
-                "X-Goog-Upload-Header-Content-Type": mime,
-                "Content-Type": "application/json",
-            }
-        )
-        display_name = str(verified.name or "resource")[:512]
-        try:
-            start = await self._client.post(
-                f"{self._base}/upload/v1beta/files",
-                headers=start_headers,
-                content=json.dumps(
-                    {"file": {"display_name": display_name}},
-                    ensure_ascii=False,
-                    separators=(",", ":"),
-                ).encode("utf-8"),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Gemini resumable upload could not start"
-            ) from exc
-        if (
-            start.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or start.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError("Gemini resumable upload start was rejected")
-        upload_url = _validated_upload_url(start.headers.get("x-goog-upload-url", ""))
-
-        provider_name = ""
-        try:
-            try:
-                finish = await self._client.post(
-                    upload_url,
-                    headers={
-                        "Content-Length": str(verified.actual_size),
-                        "X-Goog-Upload-Offset": "0",
-                        "X-Goog-Upload-Command": "upload, finalize",
-                        "Content-Type": mime,
-                    },
-                    content=self._raw_body(upload),
-                )
-            except (httpx.HTTPError, OSError) as exc:
-                raise ResourceExecutionError("Gemini resource upload failed") from exc
-            if (
-                finish.status_code < 200  # ruff: ignore[magic-value-comparison]
-                or finish.status_code >= 300  # ruff: ignore[magic-value-comparison]
-            ):
-                raise ResourceExecutionError("Gemini resource upload was rejected")
-            try:
-                meta = _file_metadata(finish.json())
-            except (json.JSONDecodeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "Gemini resource upload returned invalid metadata"
-                ) from exc
-            # Capture the provider cleanup authority before validating optional
-            # metadata such as URI/hash/state. Any later rejection can now roll
-            # back the already-created provider file.
-            provider_name = _safe_file_name(meta.get("name"))
-            checked_name, _uri, _state = self._validate_metadata(meta, upload)
-            if checked_name != provider_name:
-                raise ResourceExecutionError(
-                    "Gemini Files identity changed after upload"
-                )
-            meta = await self._wait_active(
-                name=provider_name, upload=upload, initial=meta
-            )
-            provider_name, provider_uri, state = self._validate_metadata(meta, upload)
-            if state != "ACTIVE":
-                raise ResourceExecutionError("Gemini resource did not become active")
-        except BaseException:
-            if provider_name:
-                try:  # ruff: ignore[suppressible-exception]
-                    await asyncio.shield(self._delete_name(provider_name))
-                except Exception:  # ruff: ignore[blind-except]
-                    pass
-            raise
-
-        return ProviderPrivateResource(
-            resource_id=verified.id,
-            route=route.route,
-            provider=self.name,
-            source_sha256=verified.sha256,
-            source_size=verified.actual_size,
-            opaque={
-                "file_name": provider_name,
-                "uri": provider_uri,
-                "modality": modality,
-                "mime": mime,
-                "name": verified.name,
-            },
-            cleanup_required=True,
-        )
-
-    async def release(self, handle: ProviderPrivateResource) -> None:
-        if handle.route == "tool":
-            data = _tool_opaque(handle)
-            if handle.cleanup_required:
-                await self._delete_store(data["store_name"])
-            handle.released = True
-            return
-        data = _native_opaque(handle)
-        await self._delete_name(data["file_name"])
-        handle.released = True
-
-    def interactions_payload(
-        self, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> dict:
-        upstream = build_upstream_payload(chat, reasoning_enabled=False)
-        messages = upstream.get("messages", [])
-        system = str(messages[0].get("content", "")) if len(messages) > 0 else ""
-        user_text = (
-            str(messages[1].get("content", ""))
-            if len(messages) > 1
-            else chat.user_message
-        )
-        content: list[dict] = [{"type": "text", "text": user_text}]
-        file_search_stores: list[str] = []
-        for handle in handles:
-            if handle.route == "native":
-                data = _native_opaque(handle)
-                modality = str(data.get("modality", ""))
-                mime = str(data.get("mime", ""))
-                block_type = (
-                    "image" if modality in {"image", "animated_image"} else modality
-                )
-                if block_type not in {"image", "audio", "video", "document"}:
-                    raise ResourceExecutionError(
-                        "Gemini Interactions cannot map this resource modality"
-                    )
-                block = {"type": block_type, "uri": data["uri"], "mime_type": mime}
-                content.append(block)
-            elif handle.route == "tool":
-                store = _tool_opaque(handle)["store_name"]
-                if store not in file_search_stores:
-                    file_search_stores.append(store)
-            else:
-                raise ResourceExecutionError(
-                    "Gemini Interactions received an unsupported resource route"
-                )
-        generation: dict = {
-            "max_output_tokens": chat.max_tokens,
-            "thinking_summaries": "none",
-        }
-        if chat.effort:
-            effort_map = {
-                "low": "low",
-                "medium": "medium",
-                "high": "high",
-                "extra": "high",
-                "max": "high",
-            }
-            generation["thinking_level"] = effort_map.get(chat.effort, "medium")
-        payload: dict = {
-            "model": chat.model,
-            "input": content,
-            "system_instruction": system,
-            "stream": bool(chat.stream),
-            "store": False,
-            "generation_config": generation,
-        }
-        if file_search_stores:
-            payload["tools"] = [
-                {
-                    "type": "file_search",
-                    "file_search_store_names": file_search_stores,
-                }
-            ]
-        return payload
-
-    async def open_chat(
-        self, *, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> httpx.Response:
-        payload = self.interactions_payload(chat, handles)
-        headers = self._headers()
-        headers["Content-Type"] = "application/json"
-        if chat.stream:
-            headers["Accept"] = "text/event-stream"
-        request = self._client.build_request(
-            "POST",
-            f"{self._base}/v1beta/interactions",
-            headers=headers,
-            content=json.dumps(
-                payload, ensure_ascii=False, separators=(",", ":")
-            ).encode("utf-8"),
-            timeout=self._response_timeout,
-        )
-        try:
-            return await self._client.send(request, stream=True)
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError("Gemini Interactions request failed") from exc
-
-    async def buffered_chat_response(
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> dict:
-        total = 0
-        chunks: list[bytes] = []
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                raise ResourceExecutionError(
-                    "Gemini Interactions body exceeded the configured response limit"
-                )
-            chunks.append(chunk)
-        try:
-            payload = json.loads(b"".join(chunks))
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Gemini Interactions returned invalid JSON"
-            ) from exc
-        text = _response_text(payload)
-        return {
-            "choices": [{"message": {"role": "assistant", "content": text}}],
-            "model": (
-                str(payload.get("model", "") or "") if isinstance(payload, dict) else ""
-            ),
-        }
-
-    async def chat_sse(  # ruff: ignore[too-many-branches, too-many-return-statements]
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> AsyncIterator[bytes]:
-        total = 0
-        buffer = bytearray()
-        completed = False
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_RESPONSE_TOO_LARGE","message":"The upstream response exceeded the configured limit."}}\n\n'
-                return
-            buffer.extend(chunk)
-            if (
-                len(buffer) > _MAX_SSE_EVENT_BYTES
-                and b"\n\n" not in buffer
-                and b"\r\n\r\n" not in buffer
-            ):
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_EVENT_TOO_LARGE","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                return
-            while True:
-                pos_lf = buffer.find(b"\n\n")
-                pos_crlf = buffer.find(b"\r\n\r\n")
-                candidates = [(pos_lf, 2), (pos_crlf, 4)]
-                candidates = [(pos, width) for pos, width in candidates if pos >= 0]
-                if not candidates:
-                    break
-                pos, width = min(candidates, key=lambda row: row[0])
-                if pos > _MAX_SSE_EVENT_BYTES:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_EVENT_TOO_LARGE","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                    return
-                raw = bytes(buffer[:pos])
-                del buffer[: pos + width]
-                data_lines: list[bytes] = []
-                event_name = ""
-                for line in raw.replace(b"\r\n", b"\n").split(b"\n"):
-                    if line.startswith(b"event:"):
-                        event_name = line[6:].strip().decode("utf-8", "replace")
-                    elif line.startswith(b"data:"):
-                        data_lines.append(line[5:].lstrip())
-                if not data_lines:
-                    continue
-                joined = b"\n".join(data_lines)
-                if joined == b"[DONE]":
-                    continue
-                try:
-                    payload = json.loads(joined)
-                except (json.JSONDecodeError, ValueError):
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_STREAM_INVALID","message":"The upstream provider stream was malformed."}}\n\n'
-                    return
-                if not isinstance(payload, dict):
-                    continue
-                event_type = str(payload.get("event_type", "") or event_name)
-                if event_type == "interaction.completed":
-                    interaction = payload.get("interaction")
-                    if (
-                        isinstance(interaction, dict)
-                        and interaction.get("status") == "completed"
-                    ):
-                        completed = True
-                        yield b"data: [DONE]\n\n"
-                        return
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_STREAM_INCOMPLETE","message":"The upstream interaction did not complete successfully."}}\n\n'
-                    return
-                if event_type in {
-                    "interaction.failed",
-                    "interaction.cancelled",
-                    "interaction.incomplete",
-                    "interaction.budget_exceeded",
-                    "error",
-                }:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROVIDER_ERROR","message":"The upstream provider stream failed."}}\n\n'
-                    return
-                if event_type == "step.delta":
-                    delta = payload.get("delta")
-                    if (
-                        isinstance(delta, dict)
-                        and delta.get("type") == "text"
-                        and isinstance(delta.get("text"), str)
-                    ):
-                        frame = json.dumps(
-                            {"choices": [{"delta": {"content": delta["text"]}}]},
-                            ensure_ascii=False,
-                            separators=(",", ":"),
-                        ).encode("utf-8")
-                        yield b"data: " + frame + b"\n\n"
-        if not completed:
-            yield b'event: error\ndata: {"error":{"code":"UPSTREAM_STREAM_INCOMPLETE","message":"The upstream provider stream ended before completion."}}\n\n'

_providers/huggingface.py

@@ -1,479 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Hugging Face task-aware Chat Completion resource executor.
-
-Inference Providers are heterogeneous: the OpenAI-compatible Chat Completion
-surface covers conversational LLMs and VLMs, while audio/video/other media
-families use separate task APIs.  This executor therefore owns ordinary Path-3
-chat, but enables raw resources only for exact reviewed/opted-in VLMs and
-raster-image inputs.  Browser-to-proxy transport remains raw multipart; the
-provider-private ``data:`` URL exists only inside this adapter lifecycle.
-"""
-
-from __future__ import annotations
-
-import base64
-import json
-from collections.abc import AsyncIterator, Sequence
-from urllib.parse import quote, urlparse
-
-import httpx
-
-from .executor import ProviderPrivateResource, ResourceExecutionError
-from .policy import huggingface_asr_supported_model, huggingface_vlm_supported_model
-from .registry import StaticProviderAdapter
-
-try:
-    from .._utils._chat_contract import ChatRequest, build_upstream_payload
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._chat_contract import ChatRequest, build_upstream_payload
-    from _utils._resource_transport import ResourceUpload
-
-_HF_ROUTER_BASE = "https://router.huggingface.co"
-_HF_CHAT_URL = "https://router.huggingface.co/v1/chat/completions"
-_MAX_IMAGE_BYTES = 8 * 1024 * 1024
-_MAX_TOTAL_IMAGE_BYTES = 24 * 1024 * 1024
-_MAX_SSE_EVENT_BYTES = 1024 * 1024
-_MAX_ASR_AUDIO_BYTES = 25 * 1024 * 1024
-_AUDIO_MIMES = frozenset(
-    {
-        "audio/wav",
-        "audio/mpeg",
-        "audio/flac",
-        "audio/ogg",
-        "audio/mp4",
-        "audio/aac",
-        "audio/webm",
-    }
-)
-_MODEL_ID_RE = __import__("re").compile(
-    r"^[A-Za-z0-9][A-Za-z0-9._-]{0,95}/[A-Za-z0-9][A-Za-z0-9._-]{0,159}$"
-)
-_IMAGE_MIMES = frozenset({"image/jpeg", "image/png", "image/webp"})
-
-
-class HuggingFaceAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("huggingface", **kwargs)
-
-
-def official_huggingface_router_base(value: str) -> bool:
-    """Return whether *value* is exactly the official credential destination."""
-    raw = str(value or "").strip().rstrip("/")
-    try:
-        parsed = urlparse(raw)
-    except ValueError:
-        return False
-    return bool(
-        raw == _HF_ROUTER_BASE
-        and parsed.scheme == "https"
-        and parsed.hostname == "router.huggingface.co"
-        and parsed.username is None
-        and parsed.password is None
-        and parsed.port in {None, 443}
-        and parsed.path in {"", "/"}
-        and not parsed.query
-        and not parsed.fragment
-    )
-
-
-def _bounded_json_bytes(payload: dict) -> bytes:
-    return json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode(
-        "utf-8"
-    )
-
-
-def _chat_text(payload: object) -> str:
-    if not isinstance(payload, dict) or payload.get("error"):
-        raise ResourceExecutionError(
-            "Hugging Face Chat Completion reported a provider failure"
-        )
-    choices = payload.get("choices")
-    if not isinstance(choices, list) or not choices or not isinstance(choices[0], dict):
-        raise ResourceExecutionError(
-            "Hugging Face Chat Completion returned invalid metadata"
-        )
-    message = choices[0].get("message")
-    if not isinstance(message, dict) or not isinstance(message.get("content"), str):
-        raise ResourceExecutionError(
-            "Hugging Face Chat Completion returned no assistant text"
-        )
-    text = message["content"]
-    if not text:
-        raise ResourceExecutionError(
-            "Hugging Face Chat Completion returned no assistant text"
-        )
-    return text
-
-
-def _private_image(handle: ProviderPrivateResource) -> tuple[str, str]:
-    opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-    data_url = opaque.get("data_url")
-    mime = opaque.get("mime")
-    if (
-        handle.route != "native"
-        or not isinstance(data_url, str)
-        or not data_url.startswith("data:image/")
-        or not isinstance(mime, str)
-        or mime not in _IMAGE_MIMES
-    ):
-        raise ResourceExecutionError("Hugging Face private VLM image handle is invalid")
-    return data_url, mime
-
-
-def _private_audio(handle: ProviderPrivateResource) -> tuple[bytes, str]:
-    opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-    raw = opaque.get("audio")
-    mime = opaque.get("mime")
-    if (
-        handle.route != "native"
-        or opaque.get("task") != "asr"
-        or not isinstance(raw, (bytes, bytearray))
-        or not isinstance(mime, str)
-        or mime not in _AUDIO_MIMES
-    ):
-        raise ResourceExecutionError("Hugging Face private ASR audio handle is invalid")
-    return bytes(raw), mime
-
-
-def _asr_url(model: str) -> str:
-    raw = str(model or "").strip()
-    if not _MODEL_ID_RE.fullmatch(raw):
-        raise ResourceExecutionError("Hugging Face ASR model id is invalid")
-    encoded = "/".join(quote(part, safe="-._~") for part in raw.split("/", 1))
-    return f"{_HF_ROUTER_BASE}/hf-inference/models/{encoded}"
-
-
-class HuggingFaceResourceExecutor:
-    """Execute Path-3 HF chat and exact VLM raster-image resources."""
-
-    name = "huggingface"
-    enabled = True
-
-    def __init__(
-        self,
-        *,
-        api_key: str,
-        client: httpx.AsyncClient,
-        base_url: str = _HF_ROUTER_BASE,
-        response_timeout_seconds: float = 120.0,
-        vlm_models: Sequence[str] = (),
-        asr_models: Sequence[str] = (),
-    ) -> None:
-        if not api_key:
-            raise ValueError(
-                "Hugging Face resource executor requires an inference token"
-            )
-        if not official_huggingface_router_base(base_url):
-            raise ValueError(
-                "Hugging Face resource executor requires the official router origin"
-            )
-        self._api_key = str(api_key)
-        self._client = client
-        self._response_timeout = max(1.0, float(response_timeout_seconds))
-        self._vlm_models = frozenset(
-            str(row).strip() for row in vlm_models if str(row).strip()
-        )
-        self._asr_models = frozenset(
-            str(row).strip() for row in asr_models if str(row).strip()
-        )
-
-    def _vlm(self, model: str) -> bool:
-        return huggingface_vlm_supported_model(model, extra_models=self._vlm_models)
-
-    def _asr(self, model: str) -> bool:
-        return huggingface_asr_supported_model(model, extra_models=self._asr_models)
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        out: dict[str, tuple[str, ...]] = {}
-        if self._vlm(model):
-            out["image"] = ("native",)
-        if self._asr(model):
-            out["audio"] = ("native",)
-        return out
-
-    def route_constraints(self, model: str) -> dict[str, dict[str, dict]]:
-        out: dict[str, dict[str, dict]] = {}
-        if self._vlm(model):
-            out["image"] = {
-                "native": {
-                    "max_file_bytes": _MAX_IMAGE_BYTES,
-                    "mime_types": sorted(_IMAGE_MIMES),
-                }
-            }
-        if self._asr(model):
-            out["audio"] = {
-                "native": {
-                    "max_files": 1,
-                    "max_file_bytes": _MAX_ASR_AUDIO_BYTES,
-                    "mime_types": sorted(_AUDIO_MIMES),
-                }
-            }
-        return out
-
-    async def prepare(
-        self, *, model: str, route, upload: ResourceUpload
-    ) -> ProviderPrivateResource:
-        verified = upload.verified
-        mime = str(verified.detected_mime or "").lower()
-        size = int(verified.actual_size)
-        if route.route != "native":
-            raise ResourceExecutionError("Hugging Face resource route is unsupported")
-        if verified.detected_modality == "audio":
-            if not self._asr(model) or mime not in _AUDIO_MIMES:
-                raise ResourceExecutionError(
-                    "Hugging Face ASR audio route is unsupported"
-                )
-            if size <= 0 or size > _MAX_ASR_AUDIO_BYTES:
-                raise ResourceExecutionError(
-                    "Hugging Face ASR audio exceeds the bounded 25 MiB limit"
-                )
-            await upload.upload.seek(0)
-            raw = await upload.upload.read(_MAX_ASR_AUDIO_BYTES + 1)
-            await upload.upload.seek(0)
-            if len(raw) != size or len(raw) > _MAX_ASR_AUDIO_BYTES:
-                raise ResourceExecutionError(
-                    "Hugging Face ASR audio bytes failed bounded verification"
-                )
-            return ProviderPrivateResource(
-                resource_id=verified.id,
-                route="native",
-                provider=self.name,
-                source_sha256=verified.sha256,
-                source_size=size,
-                opaque={
-                    "task": "asr",
-                    "audio": bytes(raw),
-                    "mime": mime,
-                    "modality": "audio",
-                },
-                cleanup_required=True,
-            )
-        if not self._vlm(model) or verified.detected_modality != "image":
-            raise ResourceExecutionError("Hugging Face VLM image route is unsupported")
-        if mime not in _IMAGE_MIMES:
-            raise ResourceExecutionError("Hugging Face VLM image MIME is unsupported")
-        if size <= 0 or size > _MAX_IMAGE_BYTES:
-            raise ResourceExecutionError(
-                "Hugging Face VLM image exceeds the bounded 8 MiB limit"
-            )
-        await upload.upload.seek(0)
-        raw = await upload.upload.read(_MAX_IMAGE_BYTES + 1)
-        await upload.upload.seek(0)
-        if len(raw) != size or len(raw) > _MAX_IMAGE_BYTES:
-            raise ResourceExecutionError(
-                "Hugging Face VLM image bytes failed bounded verification"
-            )
-        data_url = f"data:{mime};base64," + base64.b64encode(raw).decode("ascii")
-        return ProviderPrivateResource(
-            resource_id=verified.id,
-            route="native",
-            provider=self.name,
-            source_sha256=verified.sha256,
-            source_size=size,
-            opaque={
-                "task": "vlm",
-                "data_url": data_url,
-                "mime": mime,
-                "modality": "image",
-            },
-            cleanup_required=True,
-        )
-
-    async def release(self, handle: ProviderPrivateResource) -> None:
-        if handle.released:
-            return
-        if isinstance(handle.opaque, dict):
-            handle.opaque.clear()
-        handle.released = True
-
-    def chat_payload(
-        self, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> dict:
-        payload = build_upstream_payload(chat, reasoning_enabled=False)
-        if handles:
-            total = sum(int(row.source_size) for row in handles)
-            if total > _MAX_TOTAL_IMAGE_BYTES:
-                raise ResourceExecutionError(
-                    "Hugging Face VLM images exceed the bounded 24 MiB request limit"
-                )
-            messages = payload.get("messages")
-            if (
-                not isinstance(messages, list)
-                or len(messages) < 2  # ruff: ignore[magic-value-comparison]
-                or not isinstance(messages[1], dict)
-            ):
-                raise ResourceExecutionError(
-                    "Hugging Face Chat payload authority is invalid"
-                )
-            user_text = str(messages[1].get("content", ""))
-            content: list[dict] = [{"type": "text", "text": user_text}]
-            for handle in handles:
-                data_url, _mime = _private_image(handle)
-                content.append({"type": "image_url", "image_url": {"url": data_url}})
-            messages[1]["content"] = content
-        return payload
-
-    async def open_chat(
-        self, *, chat: ChatRequest, handles: Sequence[ProviderPrivateResource]
-    ) -> httpx.Response:
-        audio_handles = [
-            row
-            for row in handles
-            if isinstance(row.opaque, dict) and row.opaque.get("task") == "asr"
-        ]
-        if audio_handles:
-            if (
-                len(handles) != 1
-                or len(audio_handles) != 1
-                or not self._asr(chat.model)
-            ):
-                raise ResourceExecutionError(
-                    "Hugging Face ASR accepts exactly one audio resource"
-                )
-            raw, mime = _private_audio(audio_handles[0])
-            request = self._client.build_request(
-                "POST",
-                _asr_url(chat.model),
-                headers={
-                    "Authorization": f"Bearer {self._api_key}",
-                    "Content-Type": mime,
-                    "Accept": "application/json",
-                },
-                content=raw,
-                timeout=self._response_timeout,
-            )
-            try:
-                return await self._client.send(request, stream=True)
-            except (httpx.HTTPError, OSError) as exc:
-                raise ResourceExecutionError("Hugging Face ASR request failed") from exc
-        if self._asr(chat.model):
-            raise ResourceExecutionError(
-                "Hugging Face ASR requires exactly one audio resource"
-            )
-        payload = self.chat_payload(chat, handles)
-        request = self._client.build_request(
-            "POST",
-            _HF_CHAT_URL,
-            headers={
-                "Authorization": f"Bearer {self._api_key}",
-                "Content-Type": "application/json",
-                "Accept": "text/event-stream" if chat.stream else "application/json",
-            },
-            content=_bounded_json_bytes(payload),
-            timeout=self._response_timeout,
-        )
-        try:
-            return await self._client.send(request, stream=True)
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "Hugging Face Chat Completion request failed"
-            ) from exc
-
-    async def buffered_chat_response(
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> dict:
-        total = 0
-        chunks: list[bytes] = []
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                raise ResourceExecutionError(
-                    "Hugging Face Chat Completion body exceeded the response limit"
-                )
-            chunks.append(chunk)
-        try:
-            payload = json.loads(b"".join(chunks))
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "Hugging Face Chat Completion returned invalid JSON"
-            ) from exc
-        if isinstance(payload, dict) and isinstance(payload.get("text"), str):
-            text = payload["text"]
-            if not text:
-                raise ResourceExecutionError(
-                    "Hugging Face ASR returned no transcript text"
-                )
-        else:
-            text = _chat_text(payload)
-        return {
-            "choices": [{"message": {"role": "assistant", "content": text}}],
-            "model": (
-                str(payload.get("model", "") or "") if isinstance(payload, dict) else ""
-            ),
-        }
-
-    async def chat_sse(  # ruff: ignore[too-many-branches]
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> AsyncIterator[bytes]:
-        total = 0
-        buffer = bytearray()
-        done = False
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_RESPONSE_TOO_LARGE","message":"The upstream response exceeded the configured limit."}}\n\n'
-                return
-            buffer.extend(chunk)
-            if (
-                len(buffer) > _MAX_SSE_EVENT_BYTES
-                and b"\n\n" not in buffer
-                and b"\r\n\r\n" not in buffer
-            ):
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                return
-            while True:
-                marker = buffer.find(b"\n\n")
-                marker_len = 2
-                if marker < 0:
-                    marker = buffer.find(b"\r\n\r\n")
-                    marker_len = 4
-                if marker < 0:
-                    break
-                raw = bytes(buffer[:marker])
-                del buffer[: marker + marker_len]
-                if len(raw) > _MAX_SSE_EVENT_BYTES:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                    return
-                data_lines = [
-                    line[5:].lstrip()
-                    for line in raw.replace(b"\r\n", b"\n").split(b"\n")
-                    if line.startswith(b"data:")
-                ]
-                if not data_lines:
-                    continue
-                data = b"\n".join(data_lines)
-                if data == b"[DONE]":
-                    done = True
-                    break
-                try:
-                    doc = json.loads(data)
-                except (json.JSONDecodeError, ValueError):
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream was malformed."}}\n\n'
-                    return
-                if not isinstance(doc, dict) or doc.get("error"):
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_SERVICE_ERROR","message":"The upstream AI provider did not complete the streamed response."}}\n\n'
-                    return
-                choices = doc.get("choices")
-                if (
-                    isinstance(choices, list)
-                    and choices
-                    and isinstance(choices[0], dict)
-                ):
-                    delta = choices[0].get("delta")
-                    if (
-                        isinstance(delta, dict)
-                        and isinstance(delta.get("content"), str)
-                        and delta["content"]
-                    ):
-                        frame = {"choices": [{"delta": {"content": delta["content"]}}]}
-                        yield b"data: " + _bounded_json_bytes(frame) + b"\n\n"
-            if done:
-                break
-        if not done:
-            yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream ended before completion."}}\n\n'
-            return
-        yield b"data: [DONE]\n\n"

_providers/openai.py

@@ -1,553 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-OpenAI resource planning, temporary files, and Responses execution.
-
-The provider file identifier is request-private capability state.  Browser
-metadata, health documents, logs, receipts, and persisted transcripts never
-contain it.  Run 130 adds the full execution boundary: verified resources are
-uploaded first, a server-owned Responses request consumes those private handles,
-and temporary provider files are deleted after buffered or streaming completion.
-"""
-
-from __future__ import annotations
-
-import json
-import secrets
-from collections.abc import AsyncIterator, Sequence
-from urllib.parse import quote, urlparse
-
-import httpx
-
-from .executor import ProviderPrivateResource, ResourceExecutionError
-from .registry import StaticProviderAdapter
-
-try:
-    from .._utils._chat_contract import ChatRequest, build_upstream_payload
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._chat_contract import ChatRequest, build_upstream_payload
-    from _utils._resource_transport import ResourceUpload
-
-_OPENAI_BASE = "https://api.openai.com"
-_OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions"
-_UPLOAD_CHUNK_BYTES = 1024 * 1024
-_MIN_EXPIRES_SECONDS = 3600
-_MAX_EXPIRES_SECONDS = 30 * 24 * 60 * 60
-_DIRECT_FILE_LIMIT_BYTES = 50 * 1024 * 1024
-_MAX_SSE_EVENT_BYTES = 1024 * 1024
-
-
-class OpenAIAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("openai", **kwargs)
-
-
-def _validated_openai_base(value: str) -> str:
-    raw = str(value or _OPENAI_BASE).rstrip("/")
-    parsed = urlparse(raw)
-    if (
-        parsed.scheme != "https"
-        or parsed.hostname != "api.openai.com"
-        or parsed.username is not None
-        or parsed.password is not None
-        or parsed.query
-        or parsed.fragment
-        or parsed.path not in {"", "/"}
-    ):
-        raise ValueError(
-            "OpenAI resource executor requires the official HTTPS API origin"
-        )
-    return _OPENAI_BASE
-
-
-def official_openai_chat_backend(value: str) -> bool:
-    """Return whether Path-1 points exactly at the official Chat Completions URL."""
-    raw = str(value or "").strip().rstrip("/")
-    try:
-        parsed = urlparse(raw)
-    except ValueError:
-        return False
-    return bool(
-        parsed.scheme == "https"
-        and parsed.hostname == "api.openai.com"
-        and parsed.username is None
-        and parsed.password is None
-        and not parsed.query
-        and not parsed.fragment
-        and parsed.port in {None, 443}
-        and parsed.path.rstrip("/") == "/v1/chat/completions"
-        and raw == _OPENAI_CHAT_URL
-    )
-
-
-def _multipart_header(
-    boundary: str, *, purpose: str, seconds: int, upload: ResourceUpload
-) -> tuple[bytes, bytes]:
-    verified = upload.verified
-    safe_name = verified.name.replace('"', "_").replace("\r", " ").replace("\n", " ")
-    mime = verified.detected_mime or "application/octet-stream"
-    prefix = (
-        f"--{boundary}\r\n"
-        'Content-Disposition: form-data; name="purpose"\r\n\r\n'
-        f"{purpose}\r\n"
-        f"--{boundary}\r\n"
-        'Content-Disposition: form-data; name="expires_after[anchor]"\r\n\r\n'
-        "created_at\r\n"
-        f"--{boundary}\r\n"
-        'Content-Disposition: form-data; name="expires_after[seconds]"\r\n\r\n'
-        f"{seconds}\r\n"
-        f"--{boundary}\r\n"
-        f'Content-Disposition: form-data; name="file"; filename="{safe_name}"\r\n'
-        f"Content-Type: {mime}\r\n\r\n"
-    ).encode()
-    suffix = f"\r\n--{boundary}--\r\n".encode("ascii")
-    return prefix, suffix
-
-
-def _opaque_file_id(handle: ProviderPrivateResource) -> str:
-    opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-    file_id = str(opaque.get("file_id", "")).strip()
-    if (
-        not file_id
-        or len(file_id) > 256  # ruff: ignore[magic-value-comparison]
-        or not file_id.startswith("file-")
-    ):
-        raise ResourceExecutionError("OpenAI private file handle is invalid")
-    return file_id
-
-
-def _bounded_json_bytes(payload: dict) -> bytes:
-    return json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode(
-        "utf-8"
-    )
-
-
-def _response_text(payload: object) -> str:
-    """Extract only assistant-visible text from one bounded Responses JSON body."""
-    if not isinstance(payload, dict):
-        raise ResourceExecutionError("OpenAI Responses returned invalid metadata")
-    status = str(payload.get("status", "") or "")
-    if status in {"failed", "incomplete", "cancelled"} or payload.get("error"):
-        raise ResourceExecutionError("OpenAI Responses reported a provider failure")
-    top = payload.get("output_text")
-    if isinstance(top, str) and top:
-        return top
-    pieces: list[str] = []
-    output = payload.get("output")
-    if isinstance(output, list):
-        for item in output:
-            if not isinstance(item, dict) or item.get("type") != "message":
-                continue
-            content = item.get("content")
-            if not isinstance(content, list):
-                continue
-            for row in content:
-                if not isinstance(row, dict):
-                    continue
-                if row.get("type") == "output_text" and isinstance(
-                    row.get("text"), str
-                ):
-                    pieces.append(row["text"])
-                elif row.get("type") == "refusal" and isinstance(
-                    row.get("refusal"), str
-                ):
-                    pieces.append(row["refusal"])
-    text = "".join(pieces)
-    if not text:
-        raise ResourceExecutionError("OpenAI Responses returned no assistant text")
-    return text
-
-
-class OpenAIResourceExecutor:
-    """Stream verified resources to OpenAI Files and consume them with Responses."""
-
-    name = "openai"
-    enabled = True
-
-    def __init__(
-        self,
-        *,
-        api_key: str,
-        client: httpx.AsyncClient,
-        base_url: str = _OPENAI_BASE,
-        expires_seconds: int = _MIN_EXPIRES_SECONDS,
-        response_timeout_seconds: float = 600.0,
-    ) -> None:
-        key = str(api_key or "").strip()
-        if not key:
-            raise ValueError("OpenAI API key is required")
-        self._api_key = key
-        self._client = client
-        self._base = _validated_openai_base(base_url)
-        self._expires = max(
-            _MIN_EXPIRES_SECONDS,
-            min(int(expires_seconds), _MAX_EXPIRES_SECONDS),
-        )
-        self._response_timeout = httpx.Timeout(
-            connect=20.0,
-            read=max(30.0, min(float(response_timeout_seconds), 1800.0)),
-            write=120.0,
-            pool=20.0,
-        )
-
-    def executable_routes(self, model: str) -> dict[str, tuple[str, ...]]:
-        del model
-        return {
-            "text": ("native",),
-            "image": ("native",),
-            "document": ("native",),
-            "vector_image": ("tool",),
-            "data": ("tool",),
-            "archive": ("tool",),
-            "binary": ("tool",),
-        }
-
-    def _headers(self) -> dict[str, str]:
-        return {
-            "Authorization": f"Bearer {self._api_key}",
-            "Accept": "application/json",
-        }
-
-    async def _body(self, prefix: bytes, suffix: bytes, upload: ResourceUpload):
-        await upload.upload.seek(0)
-        try:
-            yield prefix
-            while True:
-                chunk = await upload.upload.read(_UPLOAD_CHUNK_BYTES)
-                if not chunk:
-                    break
-                yield chunk
-            yield suffix
-        finally:
-            await upload.upload.seek(0)
-
-    async def prepare(
-        self, *, model: str, route, upload: ResourceUpload
-    ) -> ProviderPrivateResource:
-        del model
-        verified = upload.verified
-        if route.resource_id != verified.id or route.route not in {"native", "tool"}:
-            raise ResourceExecutionError(
-                "OpenAI executor received an invalid resource route"
-            )
-        purpose = "vision" if verified.detected_modality == "image" else "user_data"
-        boundary = "scikitplots-" + secrets.token_hex(16)
-        prefix, suffix = _multipart_header(
-            boundary,
-            purpose=purpose,
-            seconds=self._expires,
-            upload=upload,
-        )
-        headers = self._headers()
-        headers.update(
-            {
-                "Content-Type": f"multipart/form-data; boundary={boundary}",
-                "Content-Length": str(len(prefix) + verified.actual_size + len(suffix)),
-            }
-        )
-        try:
-            response = await self._client.post(
-                f"{self._base}/v1/files",
-                headers=headers,
-                content=self._body(prefix, suffix, upload),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError("OpenAI temporary file upload failed") from exc
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError("OpenAI temporary file upload was rejected")
-        try:
-            payload = response.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "OpenAI temporary file upload returned invalid metadata"
-            ) from exc
-        file_id = (
-            str(payload.get("id", "")).strip() if isinstance(payload, dict) else ""
-        )
-        returned_bytes = payload.get("bytes") if isinstance(payload, dict) else None
-        if (
-            not file_id
-            or len(file_id) > 256  # ruff: ignore[magic-value-comparison]
-            or not file_id.startswith("file-")
-        ):
-            raise ResourceExecutionError(
-                "OpenAI temporary file upload returned an invalid file identifier"
-            )
-        if returned_bytes is not None:
-            try:
-                if int(returned_bytes) != int(verified.actual_size):
-                    raise ResourceExecutionError(
-                        "OpenAI temporary file size did not match source bytes"
-                    )
-            except (TypeError, ValueError) as exc:
-                raise ResourceExecutionError(
-                    "OpenAI temporary file size metadata was invalid"
-                ) from exc
-        return ProviderPrivateResource(
-            resource_id=verified.id,
-            route=route.route,
-            provider=self.name,
-            source_sha256=verified.sha256,
-            source_size=verified.actual_size,
-            opaque={
-                "file_id": file_id,
-                "purpose": purpose,
-                "modality": verified.detected_modality,
-                "mime": verified.detected_mime,
-                "name": verified.name,
-            },
-            cleanup_required=True,
-        )
-
-    async def release(self, handle: ProviderPrivateResource) -> None:
-        file_id = _opaque_file_id(handle)
-        try:
-            response = await self._client.delete(
-                f"{self._base}/v1/files/{quote(file_id, safe='-_.~')}",
-                headers=self._headers(),
-            )
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError(
-                "OpenAI temporary file cleanup failed"
-            ) from exc
-        if response.status_code == 404:  # ruff: ignore[magic-value-comparison]
-            handle.released = True
-            return
-        if (
-            response.status_code < 200  # ruff: ignore[magic-value-comparison]
-            or response.status_code >= 300  # ruff: ignore[magic-value-comparison]
-        ):
-            raise ResourceExecutionError("OpenAI temporary file cleanup was rejected")
-        try:
-            payload = response.json()
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "OpenAI temporary file cleanup returned invalid metadata"
-            ) from exc
-        if not isinstance(payload, dict) or payload.get("deleted") is not True:
-            raise ResourceExecutionError(
-                "OpenAI temporary file cleanup was not confirmed"
-            )
-        handle.released = True
-
-    def responses_payload(
-        self,
-        chat: ChatRequest,
-        handles: Sequence[ProviderPrivateResource],
-    ) -> dict:
-        """Build one server-authoritative Responses request from private file handles."""
-        provider_body = build_upstream_payload(chat, reasoning_enabled=False)
-        messages = provider_body.get("messages", [])
-        instructions = str(messages[0].get("content", "")) if len(messages) > 0 else ""
-        user_text = (
-            str(messages[1].get("content", ""))
-            if len(messages) > 1
-            else chat.user_message
-        )
-        content: list[dict] = [{"type": "input_text", "text": user_text}]
-        tool_file_ids: list[str] = []
-        direct_file_bytes = 0
-
-        for handle in handles:
-            file_id = _opaque_file_id(handle)
-            opaque = handle.opaque if isinstance(handle.opaque, dict) else {}
-            modality = str(opaque.get("modality", ""))
-            if handle.route == "tool":
-                tool_file_ids.append(file_id)
-                continue
-            if handle.route != "native":
-                raise ResourceExecutionError(
-                    "OpenAI Responses received a non-executable route"
-                )
-            if modality == "image":
-                content.append(
-                    {"type": "input_image", "file_id": file_id, "detail": "auto"}
-                )
-                continue
-            if modality not in {"text", "document"}:
-                raise ResourceExecutionError(
-                    "OpenAI direct file route does not support this modality"
-                )
-            direct_file_bytes += int(handle.source_size)
-            if (
-                int(handle.source_size) > _DIRECT_FILE_LIMIT_BYTES
-                or direct_file_bytes > _DIRECT_FILE_LIMIT_BYTES
-            ):
-                raise ResourceExecutionError(
-                    "OpenAI direct file input exceeds the bounded 50 MiB request limit"
-                )
-            content.append({"type": "input_file", "file_id": file_id})
-
-        payload: dict = {
-            "model": chat.model,
-            "instructions": instructions,
-            "input": [{"role": "user", "content": content}],
-            "max_output_tokens": chat.max_tokens,
-            "stream": bool(chat.stream),
-            "store": False,
-        }
-        if chat.effort:
-            payload["reasoning"] = {
-                "effort": {
-                    "low": "low",
-                    "medium": "medium",
-                    "high": "high",
-                    "extra": "high",
-                    "max": "high",
-                }[chat.effort]
-            }
-        if tool_file_ids:
-            payload["tools"] = [
-                {
-                    "type": "code_interpreter",
-                    "container": {
-                        "type": "auto",
-                        "memory_limit": "1g",
-                        "file_ids": tool_file_ids,
-                    },
-                }
-            ]
-            payload["tool_choice"] = "required"
-            content[0]["text"] += (
-                "\n\nProvider tool resources are attached to the code interpreter container. "
-                "Inspect them as needed to answer the user."
-            )
-        return payload
-
-    async def open_chat(
-        self,
-        *,
-        chat: ChatRequest,
-        handles: Sequence[ProviderPrivateResource],
-    ) -> httpx.Response:
-        payload = self.responses_payload(chat, handles)
-        headers = self._headers()
-        headers["Content-Type"] = "application/json"
-        request = self._client.build_request(
-            "POST",
-            f"{self._base}/v1/responses",
-            headers=headers,
-            content=_bounded_json_bytes(payload),
-            timeout=self._response_timeout,
-        )
-        try:
-            return await self._client.send(request, stream=True)
-        except (httpx.HTTPError, OSError) as exc:
-            raise ResourceExecutionError("OpenAI Responses request failed") from exc
-
-    async def open_responses(
-        self,
-        chat: ChatRequest,
-        handles: Sequence[ProviderPrivateResource],
-    ) -> httpx.Response:
-        """Internally compatibility alias for focused provider tests/tools."""
-        return await self.open_chat(chat=chat, handles=handles)
-
-    async def buffered_chat_response(
-        self, upstream: httpx.Response, *, maximum: int
-    ) -> dict:
-        total = 0
-        chunks: list[bytes] = []
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                raise ResourceExecutionError(
-                    "OpenAI Responses body exceeded the configured response limit"
-                )
-            chunks.append(chunk)
-        try:
-            payload = json.loads(b"".join(chunks))
-        except (json.JSONDecodeError, ValueError) as exc:
-            raise ResourceExecutionError(
-                "OpenAI Responses returned invalid JSON"
-            ) from exc
-        text = _response_text(payload)
-        return {
-            "choices": [{"message": {"role": "assistant", "content": text}}],
-            "model": str(payload.get("model", "") or ""),
-        }
-
-    async def chat_sse(  # ruff: ignore[too-many-branches]
-        self,
-        upstream: httpx.Response,
-        *,
-        maximum: int,
-    ) -> AsyncIterator[bytes]:
-        """Bridge Responses SSE into the panel's Chat-Completions delta vocabulary."""
-        total = 0
-        buffer = bytearray()
-        done = False
-        async for chunk in upstream.aiter_bytes():
-            total += len(chunk)
-            if total > maximum:
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_RESPONSE_TOO_LARGE","message":"The upstream response exceeded the configured limit."}}\n\n'
-                return
-            buffer.extend(chunk)
-            if (
-                len(buffer) > _MAX_SSE_EVENT_BYTES
-                and b"\n\n" not in buffer
-                and b"\r\n\r\n" not in buffer
-            ):
-                yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                return
-            while True:
-                marker = buffer.find(b"\n\n")
-                marker_len = 2
-                if marker < 0:
-                    marker = buffer.find(b"\r\n\r\n")
-                    marker_len = 4
-                if marker < 0:
-                    break
-                raw = bytes(buffer[:marker])
-                del buffer[: marker + marker_len]
-                if len(raw) > _MAX_SSE_EVENT_BYTES:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream event exceeded the configured limit."}}\n\n'
-                    return
-                event_name = ""
-                data_lines: list[bytes] = []
-                for line in raw.replace(b"\r\n", b"\n").split(b"\n"):
-                    if line.startswith(b"event:"):
-                        event_name = line[6:].strip().decode("utf-8", "replace")[:128]
-                    elif line.startswith(b"data:"):
-                        data_lines.append(line[5:].lstrip())
-                if not data_lines:
-                    continue
-                data = b"\n".join(data_lines)
-                if data == b"[DONE]":
-                    done = True
-                    break
-                try:
-                    doc = json.loads(data)
-                except (json.JSONDecodeError, ValueError):
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream was malformed."}}\n\n'
-                    return
-                kind = (
-                    str(doc.get("type", "") or event_name)
-                    if isinstance(doc, dict)
-                    else event_name
-                )
-                if kind in {"response.output_text.delta", "response.refusal.delta"}:
-                    delta = doc.get("delta", "") if isinstance(doc, dict) else ""
-                    if isinstance(delta, str) and delta:
-                        frame = {"choices": [{"delta": {"content": delta}}]}
-                        yield b"data: " + _bounded_json_bytes(frame) + b"\n\n"
-                elif kind in {"response.failed", "response.incomplete", "error"}:
-                    yield b'event: error\ndata: {"error":{"code":"UPSTREAM_SERVICE_ERROR","message":"The upstream AI provider did not complete the streamed response."}}\n\n'
-                    return
-                elif kind == "response.completed":
-                    done = True
-                    break
-            if done:
-                break
-        if not done:
-            # A Responses stream is successful only after an explicit completed
-            # terminal event.  Partial output followed by EOF must not be promoted
-            # into a Chat-Completions-style success marker.
-            yield b'event: error\ndata: {"error":{"code":"UPSTREAM_PROTOCOL_ERROR","message":"The upstream stream ended before completion."}}\n\n'
-            return
-        yield b"data: [DONE]\n\n"

_providers/policy.py

@@ -1,256 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-
-"""
-Deterministic provider resource capability policies.
-
-The selected *upstream route* owns provider identity.  Model namespaces are not
-provider authority: ``openai/gpt-oss-*`` may be served by Hugging Face, Groq,
-or another router.  This module therefore accepts an explicit adapter name from
-the proxy's routing layer and returns only provider-facility candidates.  A
-later executor must still implement the selected route before bytes leave the
-proxy.
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import Mapping
-
-from .base import ProviderResourceCapabilities
-
-_MODALITIES = (
-    "text",
-    "image",
-    "animated_image",
-    "vector_image",
-    "audio",
-    "video",
-    "document",
-    "archive",
-    "data",
-    "binary",
-)
-
-# Conservative provider-facility candidates.  These are not promises that every
-# model supports every route; model-specific deployment overrides narrow or
-# replace them.  Unknown provider/model combinations fail closed.
-_PROVIDER_DEFAULTS: dict[str, dict[str, tuple[str, ...]]] = {
-    "openai": {
-        "text": ("native", "context"),
-        "image": ("native",),
-        "document": ("native",),
-        "vector_image": ("tool", "extract"),
-        "data": ("tool",),
-        "archive": ("tool",),
-        "binary": ("tool",),
-    },
-    "anthropic": {
-        "text": ("native", "context"),
-        "image": ("native",),
-        "animated_image": ("native",),
-        "document": ("native",),
-        "vector_image": ("tool", "extract"),
-        "data": ("tool",),
-        "archive": ("tool",),
-        "binary": ("tool",),
-    },
-    "gemini": {
-        # File Search-capable Gemini models may transport a text file as a
-        # provider-managed retrieval resource; context remains the cheap
-        # bounded default when the user does not request raw/tool delivery.
-        "text": ("tool", "context"),
-        "image": ("native",),
-        "animated_image": ("native",),
-        "audio": ("native",),
-        "video": ("native",),
-        "document": ("native",),
-        "vector_image": ("extract",),
-        "data": ("tool", "extract"),
-        "archive": ("tool", "extract"),
-    },
-    # HF Inference Providers are heterogeneous.  Chat can be LLM or VLM and
-    # other media tasks use different task APIs, so the default stays text-only
-    # until the deployment declares exact model routes.
-    "huggingface": {"text": ("context",)},
-    # The bundled Qwen model Space is currently a text-only causal LM.  Future
-    # multimodal Spaces opt in through model overrides rather than changing this
-    # safe default.
-    "self_hosted": {"text": ("context",)},
-    "custom": {"text": ("context",)},
-}
-
-
-@dataclass(frozen=True)
-class ModelResourceOverride:
-    adapter: str
-    routes: Mapping[str, tuple[str, ...]]
-
-
-_HF_REVIEWED_VLM_MODELS = frozenset(
-    {
-        "Qwen/Qwen2.5-VL-3B-Instruct",
-        "zai-org/GLM-4.5V",
-        "zai-org/GLM-5.3-Flash",
-    }
-)
-
-
-def huggingface_vlm_supported_model(model: str, *, extra_models=()) -> bool:
-    """
-    Return whether *model* is an exact reviewed/opted-in HF chat VLM.
-
-    Provider suffixes (``:baseten``/``:together``/...) select an Inference
-    Provider for the same reviewed model and therefore retain the reviewed base
-    model authority.  Deployment additions are exact full model strings.
-    """
-    raw = str(model or "").strip()
-    base = raw.rsplit(":", 1)[0] if ":" in raw else raw
-    extras = {str(row).strip() for row in extra_models if str(row).strip()}
-    return base in _HF_REVIEWED_VLM_MODELS or raw in extras
-
-
-_HF_REVIEWED_ASR_MODELS = frozenset({"openai/whisper-large-v3"})
-
-
-def huggingface_asr_supported_model(model: str, *, extra_models=()) -> bool:
-    """
-    Return whether *model* is an exact reviewed/opted-in HF ASR task model.
-
-    Unlike Chat/VLM provider suffixes, this executor pins the ``hf-inference``
-    ASR task endpoint directly, so ASR authority is an exact model id rather
-    than an OpenAI-compatible provider-qualified chat id.
-    """
-    raw = str(model or "").strip()
-    extras = {str(row).strip() for row in extra_models if str(row).strip()}
-    return raw in _HF_REVIEWED_ASR_MODELS or raw in extras
-
-
-def gemini_native_media_supported_model(model: str) -> bool:
-    """
-    Return whether current Gemini docs list native image/video/audio/PDF input.
-
-    Provider-wide Files storage is not model execution authority.  Keep this
-    deliberately narrow so unknown/future model ids fail closed until reviewed.
-    """
-    raw = str(model or "").strip().lower()
-    return raw in {
-        "gemini-3.8-flash",
-        "gemini-3.7-flash",
-        "gemini-3.6-flash",
-        "gemini-3.5-flash",
-        "gemini-3.5-flash-lite",
-        "gemini-3-flash-preview",
-    }
-
-
-def gemini_file_search_supported_model(model: str) -> bool:
-    """
-    Return whether current Gemini docs list *model* for File Search.
-
-    Files storage and native multimodal input are separate facilities.  File
-    Search creates persistent indexed stores and has its own model list, so
-    unknown/future models fail closed until that compatibility table is
-    deliberately reviewed.
-    """
-    raw = str(model or "").strip().lower()
-    return raw in {
-        "gemini-3.8-flash",
-        "gemini-3.7-flash",
-        "gemini-3.6-flash",
-        "gemini-3.5-flash",
-        "gemini-3.5-flash-lite",
-        "gemini-3.1-pro-preview",
-        "gemini-3.1-flash-lite",
-        "gemini-3-flash-preview",
-    }
-
-
-def anthropic_code_execution_supported_model(model: str) -> bool:
-    """
-    Return whether current Claude API docs list *model* for Code Execution.
-
-    The provider Files API may store arbitrary data, but storage is not model
-    execution authority.  Unknown/future model families therefore fail closed
-    until this policy is deliberately updated.
-    """
-    raw = str(model or "").strip().lower()
-    patterns = (
-        r"^claude-(?:opus|sonnet)-5(?:-\d{8})?$",
-        r"^claude-(?:fable|mythos)-5(?:-1)?(?:-\d{8})?$",
-        r"^claude-opus-4-(?:5|6|7|8)(?:-\d{8})?$",
-        r"^claude-sonnet-4-(?:5|6)(?:-\d{8})?$",
-        r"^claude-haiku-4-5(?:-\d{8})?$",
-    )
-    return any(re.match(pattern, raw) for pattern in patterns)
-
-
-def provider_names() -> tuple[str, ...]:
-    return tuple(sorted(_PROVIDER_DEFAULTS))
-
-
-def default_routes(adapter: str) -> dict[str, tuple[str, ...]]:
-    raw = _PROVIDER_DEFAULTS.get(str(adapter or "").strip().lower(), {})
-    return {m: tuple(raw.get(m, ("unsupported",))) for m in _MODALITIES}
-
-
-def capabilities_for(
-    *,
-    adapter: str,
-    model: str,
-    overrides: Mapping[str, ModelResourceOverride] | None = None,
-    max_files: int | None = None,
-    max_file_bytes: int | None = None,
-    max_total_bytes: int | None = None,
-) -> ProviderResourceCapabilities:
-    name = str(adapter or "custom").strip().lower()
-    routes = default_routes(name)
-    if name == "anthropic" and not anthropic_code_execution_supported_model(model):
-        # Native images/text/PDF remain direct.  Tool routes require a Claude
-        # family explicitly documented for server-side Code Execution.
-        for modality in ("vector_image", "data", "archive", "binary"):
-            routes[modality] = tuple(
-                route for route in routes.get(modality, ()) if route != "tool"
-            ) or ("unsupported",)
-    if name == "huggingface":
-        if huggingface_asr_supported_model(model):
-            # ASR is a separate raw-audio task, not a conversational chat model.
-            routes["text"] = ("unsupported",)
-            routes["audio"] = ("native",)
-        elif huggingface_vlm_supported_model(model):
-            # Chat Completion is the reviewed execution surface for conversational
-            # VLMs. Other HF media tasks are separate APIs and remain fail-closed.
-            routes["image"] = ("native",)
-    if name == "gemini":
-        if not gemini_native_media_supported_model(model):
-            # Files storage and Interactions availability are not model modality
-            # authority. Unknown/future Gemini models retain text-context only.
-            for modality in ("image", "animated_image", "audio", "video", "document"):
-                routes[modality] = ("unsupported",)
-        if not gemini_file_search_supported_model(model):
-            # File Search is a separate persistent retrieval facility with its
-            # own compatibility table. Remove only its tool route; local
-            # context/extract candidates remain available to other execution
-            # planes when deliberately implemented.
-            for modality in ("text", "data", "archive"):
-                kept = tuple(
-                    route for route in routes.get(modality, ()) if route != "tool"
-                )
-                routes[modality] = kept or ("unsupported",)
-    override = (overrides or {}).get(model)
-    if override is not None and str(override.adapter or "").strip().lower() == name:
-        # Overrides are provider-scoped.  A model string may be served through
-        # multiple upstreams, so one adapter's declaration must never bleed into
-        # another adapter merely because the model id matches.
-        routes = {
-            m: tuple(override.routes.get(m, ("unsupported",))) for m in _MODALITIES
-        }
-    return ProviderResourceCapabilities(
-        provider=name,
-        model=model,
-        modality_routes=routes,
-        max_files=max_files,
-        max_file_bytes=max_file_bytes,
-        max_total_bytes=max_total_bytes,
-    )

_providers/registry.py

@@ -1,124 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-"""Provider adapter registry and route planning for verified resources."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Mapping, Sequence
-
-from .base import ProviderResourceCapabilities, ResourceRoute
-from .policy import ModelResourceOverride, capabilities_for, provider_names
-
-try:
-    from .._utils._resource_transport import ResourceUpload
-except ImportError:  # standalone HF Space: _providers is top-level
-    from _utils._resource_transport import ResourceUpload
-
-_AUTO_ORDER = ("native", "tool", "extract", "context")
-
-
-@dataclass
-class StaticProviderAdapter:
-    """
-    Plan resource routes without performing provider I/O.
-
-    Run 127 deliberately stops at a verifiable routing plan.  Provider-specific
-    upload/execution modules added later consume these plans.  Keeping planning
-    separate makes health discovery truthful and testable without credentials.
-    """
-
-    name: str
-    overrides: Mapping[str, ModelResourceOverride] | None = None
-    max_files: int | None = None
-    max_file_bytes: int | None = None
-    max_total_bytes: int | None = None
-
-    def capabilities(self, model: str) -> ProviderResourceCapabilities:
-        return capabilities_for(
-            adapter=self.name,
-            model=model,
-            overrides=self.overrides,
-            max_files=self.max_files,
-            max_file_bytes=self.max_file_bytes,
-            max_total_bytes=self.max_total_bytes,
-        )
-
-    async def route_resources(
-        self, model: str, resources: Sequence[ResourceUpload]
-    ) -> Sequence[ResourceRoute]:
-        caps = self.capabilities(model)
-        planned: list[ResourceRoute] = []
-        for upload in resources:
-            verified = upload.verified
-            candidates = tuple(caps.routes_for(verified.detected_modality))
-            intent = verified.intent
-            route = "unsupported"
-            if intent == "raw":
-                for candidate in ("native", "tool"):
-                    if candidate in candidates:
-                        route = candidate
-                        break
-            elif intent == "extract":
-                if "extract" in candidates:
-                    route = "extract"
-            elif intent == "context":
-                if "context" in candidates:
-                    route = "context"
-            else:
-                for candidate in _AUTO_ORDER:
-                    if candidate in candidates:
-                        route = candidate
-                        break
-            planned.append(
-                ResourceRoute(
-                    resource_id=verified.id,
-                    route=route,
-                    reason=(
-                        "planned provider route"
-                        if route != "unsupported"
-                        else f"{caps.provider} adapter has no route for {verified.detected_modality}/{intent}"
-                    ),
-                    metadata={
-                        "provider": caps.provider,
-                        "model": model,
-                        "modality": verified.detected_modality,
-                        "intent": intent,
-                        "candidates": list(candidates),
-                        "execution": "plan-only",
-                    },
-                )
-            )
-        return tuple(planned)
-
-    async def close(self) -> None:
-        return None
-
-
-class ProviderRegistry:
-    def __init__(
-        self,
-        *,
-        overrides: Mapping[str, ModelResourceOverride] | None = None,
-        max_files: int | None = None,
-        max_file_bytes: int | None = None,
-        max_total_bytes: int | None = None,
-    ) -> None:
-        self._adapters = {
-            name: StaticProviderAdapter(
-                name,
-                overrides=overrides,
-                max_files=max_files,
-                max_file_bytes=max_file_bytes,
-                max_total_bytes=max_total_bytes,
-            )
-            for name in provider_names()
-        }
-
-    def get(self, name: str) -> StaticProviderAdapter:
-        return self._adapters.get(
-            str(name or "").strip().lower(), self._adapters["custom"]
-        )
-
-    def names(self) -> tuple[str, ...]:
-        return tuple(sorted(self._adapters))

_providers/self_hosted.py

@@ -1,10 +0,0 @@
-# Authors: The scikit-plots developers
-# SPDX-License-Identifier: BSD-3-Clause
-"""Bundled/self-hosted model resource adapter marker."""
-
-from .registry import StaticProviderAdapter
-
-
-class SelfHostedAdapter(StaticProviderAdapter):
-    def __init__(self, **kwargs):
-        super().__init__("self_hosted", **kwargs)