ctfy.sdk.resources.vendor

  1"""``client.vendor`` — read-only vendor tenancy (authenticate with a ``pv_`` token)."""
  2
  3from __future__ import annotations
  4
  5import builtins
  6
  7from ctfy.core.state.models import (
  8    EvalCampaignState,
  9    EvalRunState,
 10    LlmModelState,
 11    VendorKeyState,
 12    VendorState,
 13)
 14from ctfy.sdk._helpers import PagedList, _extract_items, _raise_for_status
 15from ctfy.sdk.base import BaseHttpClient
 16from ctfy.server.models import VendorStandardSet
 17
 18
 19class VendorResource:
 20    """The calling vendor's own profile / models / runs.
 21
 22    Requires a ``pv_`` bearer (minted by an admin); the token resolves to a
 23    single vendor and exposes only that vendor's data — never the platform's.
 24    """
 25
 26    def __init__(self, http: BaseHttpClient) -> None:
 27        self._http = http
 28
 29    def me(self) -> VendorState:
 30        resp = self._http.request("GET", "/vendor/me")
 31        _raise_for_status(resp)
 32        return VendorState.model_validate(resp.json())
 33
 34    def models(self) -> builtins.list[LlmModelState]:
 35        resp = self._http.request("GET", "/vendor/models")
 36        _raise_for_status(resp)
 37        return [LlmModelState.model_validate(row) for row in resp.json()]
 38
 39    def runs(
 40        self, *, offset: int = 0, limit: int = 100, fully_solved: bool | None = None
 41    ) -> PagedList[EvalRunState]:
 42        """This vendor's runs, newest first — one page, with the total.
 43
 44        ``fully_solved`` narrows to runs that did (``True``) or did not
 45        (``False``) solve their whole challenge; ``.total`` then counts
 46        the narrowed set, so ``runs(fully_solved=True, limit=1).total``
 47        is how many runs solved, without reading them.
 48        """
 49        params: dict[str, int | bool] = {"offset": offset, "limit": limit}
 50        if fully_solved is not None:
 51            params["fully_solved"] = fully_solved
 52        resp = self._http.request("GET", "/vendor/runs", params=params)
 53        _raise_for_status(resp)
 54        return _extract_items(resp.json(), EvalRunState)
 55
 56    def standard_sets(self) -> builtins.list[VendorStandardSet]:
 57        """The operator eval standard sets a vendor may launch a campaign over
 58        (id / title / challenge count / corpus pin — the launch-picker source)."""
 59        resp = self._http.request("GET", "/vendor/standard-sets")
 60        _raise_for_status(resp)
 61        return [VendorStandardSet.model_validate(row) for row in resp.json()]
 62
 63    def register_model(
 64        self,
 65        *,
 66        id: str,
 67        flavor: str,
 68        display_name: str = "",
 69        provider_model: str = "",
 70        base_url: str = "",
 71        notes: str = "",
 72    ) -> LlmModelState:
 73        """Self-register (or edit) one of the vendor's own models. Requires a
 74        ``submit``-scoped ``pv_`` token. The model lands ``pending`` review —
 75        an operator must approve it before it can run official campaigns."""
 76        resp = self._http.request(
 77            "POST",
 78            "/vendor/models",
 79            json={
 80                "id": id,
 81                "flavor": flavor,
 82                "display_name": display_name,
 83                "provider_model": provider_model,
 84                "base_url": base_url,
 85                "notes": notes,
 86            },
 87        )
 88        _raise_for_status(resp)
 89        return LlmModelState.model_validate(resp.json())
 90
 91    def upload_key(self, *, flavor: str, api_key: str, label: str = "") -> VendorKeyState:
 92        """Upload (or replace) the vendor's model API key for a flavor. Requires
 93        a ``submit``-scoped token. The key is encrypted at rest; the returned
 94        row carries only metadata (never the ciphertext)."""
 95        resp = self._http.request(
 96            "POST",
 97            "/vendor/keys",
 98            json={"flavor": flavor, "api_key": api_key, "label": label},
 99        )
100        _raise_for_status(resp)
101        return VendorKeyState.model_validate(resp.json())
102
103    def keys(self) -> builtins.list[VendorKeyState]:
104        """List the vendor's uploaded key metadata (ciphertext blanked)."""
105        resp = self._http.request("GET", "/vendor/keys")
106        _raise_for_status(resp)
107        return [VendorKeyState.model_validate(row) for row in resp.json()]
108
109    def delete_key(self, vendor_key_id: str) -> bool:
110        resp = self._http.request("DELETE", f"/vendor/keys/{vendor_key_id}")
111        _raise_for_status(resp)
112        return bool(resp.json().get("deleted"))
113
114    def campaigns(self, *, offset: int = 0, limit: int = 50) -> PagedList[EvalCampaignState]:
115        """The vendor's own campaigns (sandbox + self-reported), newest
116        first — one page, with the total (``limit`` at most 200)."""
117        resp = self._http.request(
118            "GET", "/vendor/campaigns", params={"offset": offset, "limit": limit}
119        )
120        _raise_for_status(resp)
121        return _extract_items(resp.json(), EvalCampaignState)
122
123    def submit_campaign(
124        self,
125        *,
126        model_id: str,
127        standard_set_id: str,
128        name: str = "",
129        num_samples: int = 1,
130        max_cost_usd: float = 0.0,
131        timeout_s: int = 0,
132        max_turns: int = 0,
133        publish: bool = False,
134    ) -> EvalCampaignState:
135        """Self-trigger a batch over an operator standard set on the vendor's
136        own key. ``publish=False`` → a private ``sandbox`` run; ``publish=True``
137        → a public but unverified ``self_reported`` run (requires an approved
138        model). Requires a ``submit``-scoped token + an uploaded key for the
139        model's flavor. Poll :meth:`campaigns` for progress."""
140        resp = self._http.request(
141            "POST",
142            "/vendor/campaigns",
143            json={
144                "model_id": model_id,
145                "standard_set_id": standard_set_id,
146                "name": name,
147                "num_samples": num_samples,
148                "max_cost_usd": max_cost_usd,
149                "timeout_s": timeout_s,
150                "max_turns": max_turns,
151                "publish": publish,
152            },
153        )
154        _raise_for_status(resp)
155        return EvalCampaignState.model_validate(resp.json())