unitysvc-core 0.2.7__tar.gz → 0.2.9__tar.gz

{unitysvc_core-0.2.7/src/unitysvc_core.egg-info → unitysvc_core-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.7
+Version: 0.2.9
 Summary: Shared data models and validation helpers for UnitySVC packages
 Author-email: Bo Peng <bo.peng@unitysvc.com>
 Maintainer-email: Bo Peng <bo.peng@unitysvc.com>

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.7"
+version = "0.2.9"
 description = "Shared data models and validation helpers for UnitySVC packages"
 readme = "README.md"
 authors = [{ name = "Bo Peng", email = "bo.peng@unitysvc.com" }]

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/src/unitysvc_core/models/__init__.py

@@ -72,7 +72,6 @@ from .service import (
     RateLimit,
     ServiceConstraints,
     ServiceStatus,
-    UpstreamAccessConfigData,
 )
 from .service_group_data import (
     SERVICE_GROUP_SCHEMA_VERSION,
@@ -108,7 +107,6 @@ __all__ = [
     # Shared / access models
     "DocumentData",
     "AccessInterfaceData",
-    "UpstreamAccessConfigData",
     "RateLimit",
     "ServiceConstraints",
     "ServiceStatus",

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/src/unitysvc_core/models/base.py

@@ -243,11 +243,11 @@ class RequestTransformEnum(StrEnum):
     body_transformer = "body_transformer"
     # Simple body replacement from rendered enrollment data
     set_body = "set_body"
-    # Translate the request/response between the client's LLM API format and the
-    # format the upstream provider accepts (e.g. Anthropic Messages -> OpenAI
-    # Chat). Config carries ``upstream_format``; the gateway performs the
-    # conversion in-process (#923/#929).
-    llm_translate = "llm_translate"
+    # Translate the request/response between LLM API formats (Anthropic Messages
+    # <-> OpenAI Chat). The value names the converter (e.g. ``anthropic_to_openai``);
+    # the gateway auto-detects the incoming format and translates in-process only
+    # when needed (#923/#929/#1400). Replaces the earlier ``llm_translate`` key.
+    llm_translator = "llm_translator"
 
 
 class ServiceTypeEnum(StrEnum):

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/src/unitysvc_core/models/offering_v1.py

@@ -6,7 +6,6 @@ from pydantic import ConfigDict, Field, HttpUrl, field_validator
 from .documents import DocumentData
 from .offering_data import ServiceOfferingData
 from .pricing import Pricing
-from .service import UpstreamAccessConfigData
 from .validators import validate_channel_name, validate_service_identifier
 
 
@@ -44,9 +43,15 @@ class OfferingV1(ServiceOfferingData):
     # Convenience field for logo (converted to documents during import)
     logo: str | HttpUrl | None = None
 
-    # Override with typed models for file validation
-    upstream_access_config: dict[str, UpstreamAccessConfigData] = Field(  # type: ignore[assignment]
-        description="Upstream access channels, keyed by channel name",
+    # Required in file validation (base allows None for API flexibility). Each
+    # value is an OPAQUE per-channel JSON object: the gateway reads
+    # upstream_access_config as raw JSONB, and channels are genuinely
+    # heterogeneous (http has base_url; smtp has host/port; s3 has bucket/region;
+    # a raw channel wraps arbitrary fields). A typed model here enforced nothing
+    # (extra="allow") while misfitting non-HTTP channels — so it is intentionally
+    # left open and validated by the gateway/backend at use. See unitysvc/unitysvc#1717.
+    upstream_access_config: dict[str, dict[str, Any]] = Field(  # type: ignore[assignment]
+        description="Upstream access channels, keyed by channel name (opaque per-channel objects)",
     )
 
     documents: dict[str, DocumentData] | None = Field(  # type: ignore[assignment]
@@ -72,7 +77,7 @@ class OfferingV1(ServiceOfferingData):
 
     @field_validator("upstream_access_config")
     @classmethod
-    def validate_channel_names(cls, v: dict[str, UpstreamAccessConfigData]) -> dict[str, UpstreamAccessConfigData]:
+    def validate_channel_names(cls, v: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
         """Validate every channel name (key of ``upstream_access_config``).
 
         Channel names are selected via the ``<name>@<channel>`` identifier

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/src/unitysvc_core/models/service.py

@@ -38,6 +38,15 @@ class RateLimit(BaseModel):
 
 
 class ServiceConstraints(BaseModel):
+    """DEPRECATED — planned SLA/quota surface that was never enforced.
+
+    No routing resolver or gateway path ever read these fields; they were
+    authored nowhere in seller data. The ``constraints`` field has been removed
+    from ``AccessInterfaceData``. The class is retained (still exported) only so
+    existing imports do not break; it is unused and slated for removal. Do not
+    add new references. See unitysvc/unitysvc#1717.
+    """
+
     model_config = ConfigDict(extra="forbid")
 
     # Usage Quotas & Billing
@@ -81,7 +90,21 @@ class ServiceConstraints(BaseModel):
 
 
 class AccessInterfaceData(BaseModel):
-    """User-facing access interface data (customer side).
+    """User-facing access interface data — a **pure routing-resolution object**.
+
+    It answers "which candidate does this request address?" — nothing more. It
+    carries only the customer-facing address (``base_url``), the request
+    ``routing_key``, and selection/visibility metadata (``is_active`` /
+    ``is_primary`` / ``sort_order``). All upstream-access and enforcement
+    concerns (endpoint credentials, transformers, response-eval rules, rate
+    limits) live on the per-channel ``upstream_access_config`` entry — an
+    opaque JSON object the gateway reads as raw JSONB — which is where the
+    gateway resolves them.
+
+    Historically this also carried ``rate_limits`` / ``constraints`` /
+    ``response_rules``; those were authored nowhere in customer-facing
+    interfaces and have moved to the channel (rate limits) or been dropped
+    (``constraints`` — never enforced). See unitysvc/unitysvc#1717.
 
     Note: The interface name is NOT stored here - it's the key in the interfaces dict.
     When stored in the database, the backend extracts the key as the name field.
@@ -100,61 +123,11 @@ class AccessInterfaceData(BaseModel):
         description="Request routing key for matching (e.g., {'model': 'gpt-4'})",
     )
 
-    rate_limits: list[RateLimit] | None = Field(
-        default=None,
-        description="Rate limit",
-    )
-    constraints: ServiceConstraints | None = Field(default=None, description="Service constraints and conditions")
-    response_rules: dict[str, dict[str, Any] | str] | None = Field(
-        default=None,
-        description="Response evaluation rules keyed by rule name. "
-        "Values are either a rule dict or a Jinja2 template string. Validated by the backend.",
-    )
     is_active: bool = Field(default=True, description="Whether interface is active")
     is_primary: bool = Field(default=False, description="Whether this is the primary interface")
     sort_order: int = Field(default=0, description="Display order")
 
 
-class UpstreamAccessConfigData(AccessInterfaceData):
-    """One upstream access channel — a named entry in ``upstream_access_config``.
-
-    Each channel is a complete way for the gateway to reach the upstream: a wire
-    protocol (``access_method``), endpoint (``base_url``), credential (``api_key``),
-    routing key, and rate-limit/quality restrictions. A service may declare several
-    channels (keyed by free-form channel name, e.g. ``"managed"``, ``"byok"``,
-    ``"managed-eu"``); the gateway selects one per request.
-
-    The channel's *type* is derived from its credential/endpoint provenance:
-    ``managed`` (seller's key, ``${ secrets.* }``), ``byok`` (customer's key,
-    ``${ customer_secrets.* }``), or ``byoe`` (customer's key + customer-templated
-    ``base_url``).
-
-    Extends AccessInterfaceData with extra="allow" to support protocol-specific
-    configuration fields (e.g., S3 bucket/region, SMTP host/port) that the
-    gateway needs to reach the upstream service.
-    """
-
-    model_config = ConfigDict(extra="allow")
-
-    # base_url is optional for upstream configs (e.g., S3 uses bucket + region instead)
-    base_url: str | None = Field(default=None, max_length=500, description="Base URL for api access")  # type: ignore[assignment]
-
-    api_key: str | None = Field(
-        default=None,
-        max_length=2000,
-        description=(
-            "Upstream API key, or a svcpass disposition (#1198). The value "
-            "controls what the gateway does with the inbound svcpass token "
-            "before forwarding upstream: unset/'' or '__strip__' strip the "
-            "svcpass-bearing header (other auth headers pass through); "
-            "'__forward__' keeps svcpass on its original header (only to a "
-            "trusted platform host); any other value (a '${ secrets.X }' / "
-            "'${ customer_secrets.X }' reference) overrides svcpass with that "
-            "credential on the source header."
-        ),
-    )
-
-
 class ServiceStatus(BaseModel):
     """Backend-assigned service **status / identity sidecar** (the ``service.json``
     file) — *not* the authored service data.

{unitysvc_core-0.2.7 → unitysvc_core-0.2.9}/src/unitysvc_core/models/validators.py

@@ -253,7 +253,7 @@ def validate_channel_name(name: str, entity_type: str = "channel") -> str:
 
 
 SUPPORTED_SERVICE_OPTIONS: dict[str, type | tuple[type, ...]] = {
-    "enrollment": dict,  # Per-enrollment config: {scope, limit, limit_per_customer, limit_per_user}
+    "enrollment": dict,  # Per-enrollment config: {limit, limit_per_customer, limit_per_user}
     "routing_vars": dict,  # Seller-managed operational variables for template resolution at request time
     "ops_testing_parameters": dict,
     "prompt_recurrence": bool,  # Prompt recurrence options during enrollment
@@ -264,7 +264,6 @@ SUPPORTED_SERVICE_OPTIONS: dict[str, type | tuple[type, ...]] = {
 
 # Inner keys of the ``enrollment`` service option and their expected types.
 SUPPORTED_ENROLLMENT_OPTIONS: dict[str, type | tuple[type, ...]] = {
-    "scope": str,  # "customer" (default) | "global"
     "limit": int,  # global active-enrollment cap per service
     "limit_per_customer": int,
     "limit_per_user": int,
@@ -294,8 +293,6 @@ def _validate_enrollment_option(value: dict[str, Any]) -> list[str]:
             type_name = expected_type.__name__ if isinstance(expected_type, type) else str(expected_type)
             errors.append(f"service_options.enrollment.{key} must be {type_name}, got {type(val).__name__}")
             continue
-        if key == "scope" and val not in ("customer", "global"):
-            errors.append(f"service_options.enrollment.scope must be 'customer' or 'global', got {val!r}")
         if key.startswith("limit") and isinstance(val, int) and val <= 0:
             errors.append(f"service_options.enrollment.{key} must be a positive integer, got {val}")
     return errors
@@ -332,7 +329,7 @@ def validate_service_options(service_options: dict[str, Any] | None) -> list[str
             errors.append(f"service_options.{key} must be {type_name}, got {type(value).__name__}")
             continue
 
-        # Validate the nested enrollment config (scope / limit*).
+        # Validate the nested enrollment config (limit*).
         if key == "enrollment" and isinstance(value, dict):
             errors.extend(_validate_enrollment_option(value))