unitysvc-core 0.2.4__tar.gz → 0.2.5__tar.gz

{unitysvc_core-0.2.4/src/unitysvc_core.egg-info → unitysvc_core-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.4
+Version: 0.2.5
 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.4 → unitysvc_core-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "unitysvc-core"
-version = "0.2.4"
+version = "0.2.5"
 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.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/__init__.py

@@ -33,6 +33,7 @@ from .offering_v1 import OfferingV1
 from .pricing import (
     AddPriceData,
     BasePriceData,
+    ChannelPriceData,
     ConstantPriceData,
     CountPriceData,
     DataPriceData,
@@ -43,7 +44,6 @@ from .pricing import (
     ImagePriceData,
     MaxPriceData,
     MinPriceData,
-    ModePriceData,
     MultiplyPriceData,
     PercentageStr,
     PriceStr,
@@ -159,7 +159,7 @@ __all__ = [
     "MultiplyPriceData",
     "MaxPriceData",
     "MinPriceData",
-    "ModePriceData",
+    "ChannelPriceData",
     "FirstPriceData",
     "TieredPriceData",
     "GraduatedPriceData",

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/base.py

@@ -216,8 +216,8 @@ class PricingTypeEnum(StrEnum):
     graduated = "graduated"  # Graduated tiers (each tier's units at that rate)
     # Expression-based pricing (payout_price only)
     expr = "expr"  # Arbitrary expression using usage metrics
-    # Mode-based pricing: select a sub-price by the request's resolved mode
-    mode = "mode"  # Per-mode pricing keyed by mode name (e.g. managed, byok)
+    # Channel-based pricing: select a sub-price by the request's resolved channel
+    channel = "channel"  # Per-channel pricing keyed by channel name (e.g. managed, byok)
 
 
 class QuotaResetCycleEnum(StrEnum):

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/offering_data.py

@@ -91,10 +91,10 @@ class ServiceOfferingData(BaseModel):
         description="Payout pricing: How to calculate seller payout",
     )
 
-    # Access interfaces (keyed by name)
+    # Access channels (keyed by channel name)
     upstream_access_config: dict[str, dict[str, Any]] | None = Field(
         default=None,
-        description="Upstream access interfaces, keyed by name",
+        description="Upstream access channels, keyed by channel name",
     )
 
     # Documents (keyed by title)

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/offering_v1.py

@@ -46,7 +46,7 @@ class OfferingV1(ServiceOfferingData):
 
     # Override with typed models for file validation
     upstream_access_config: dict[str, UpstreamAccessConfigData] = Field(  # type: ignore[assignment]
-        description="Upstream access interfaces, keyed by name",
+        description="Upstream access channels, keyed by channel name",
     )
 
     documents: dict[str, DocumentData] | None = Field(  # type: ignore[assignment]

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/pricing.py

@@ -280,7 +280,7 @@ class TokenPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for token-based pricing.
 
@@ -347,7 +347,7 @@ class TimePriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for time-based pricing.
 
@@ -388,7 +388,7 @@ class ImagePriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for image-based pricing.
 
@@ -425,7 +425,7 @@ class StepPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for step-based pricing.
 
@@ -465,7 +465,7 @@ class DataPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for data-volume pricing.
 
@@ -509,7 +509,7 @@ class CountPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for count-scaled pricing.
 
@@ -572,7 +572,7 @@ class RevenueSharePriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost for revenue share pricing.
 
@@ -612,7 +612,7 @@ class ConstantPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Return the constant price regardless of usage.
 
@@ -685,7 +685,7 @@ class AddPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate total cost by summing all price components.
 
@@ -700,7 +700,7 @@ class AddPriceData(BasePriceData):
         total = Decimal("0")
         for price_data in self.prices:
             component = validate_pricing(price_data)
-            total += component.calculate_cost(usage, customer_charge, request_count, mode)
+            total += component.calculate_cost(usage, customer_charge, request_count, channel)
         return total
 
 
@@ -745,7 +745,7 @@ class MultiplyPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost by multiplying base price by factor.
 
@@ -758,7 +758,7 @@ class MultiplyPriceData(BasePriceData):
             Base cost multiplied by factor
         """
         base_pricing = validate_pricing(self.base)
-        base_cost = base_pricing.calculate_cost(usage, customer_charge, request_count, mode)
+        base_cost = base_pricing.calculate_cost(usage, customer_charge, request_count, channel)
         return base_cost * Decimal(self.factor)
 
 
@@ -799,7 +799,7 @@ class MaxPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Return the highest cost among applicable children.
 
@@ -810,7 +810,7 @@ class MaxPriceData(BasePriceData):
         for price_data in self.prices:
             try:
                 component = validate_pricing(price_data)
-                costs.append(component.calculate_cost(usage, customer_charge, request_count, mode))
+                costs.append(component.calculate_cost(usage, customer_charge, request_count, channel))
             except ValueError:
                 continue
         if not costs:
@@ -857,7 +857,7 @@ class MinPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Return the lowest cost among applicable children.
 
@@ -868,7 +868,7 @@ class MinPriceData(BasePriceData):
         for price_data in self.prices:
             try:
                 component = validate_pricing(price_data)
-                costs.append(component.calculate_cost(usage, customer_charge, request_count, mode))
+                costs.append(component.calculate_cost(usage, customer_charge, request_count, channel))
             except ValueError:
                 continue
         if not costs:
@@ -914,7 +914,7 @@ class FirstPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Return the cost from the first child that can handle the usage.
 
@@ -925,7 +925,7 @@ class FirstPriceData(BasePriceData):
         for price_data in self.prices:
             try:
                 component = validate_pricing(price_data)
-                return component.calculate_cost(usage, customer_charge, request_count, mode)
+                return component.calculate_cost(usage, customer_charge, request_count, channel)
             except ValueError:
                 continue
         raise ValueError("No child pricing could handle the provided usage data")
@@ -1140,7 +1140,7 @@ class ExprPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost by evaluating the expression with usage data.
 
@@ -1214,7 +1214,7 @@ class TieredPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost based on which tier the usage falls into.
 
@@ -1232,7 +1232,7 @@ class TieredPriceData(BasePriceData):
         for tier in self.tiers:
             if tier.up_to is None or metric_value <= tier.up_to:
                 tier_pricing = validate_pricing(tier.price)
-                return tier_pricing.calculate_cost(usage, customer_charge, request_count, mode)
+                return tier_pricing.calculate_cost(usage, customer_charge, request_count, channel)
 
         # Should not reach here if tiers are properly configured
         raise ValueError("No matching tier found")
@@ -1297,7 +1297,7 @@ class GraduatedPriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
         """Calculate cost with graduated pricing across tiers.
 
@@ -1333,56 +1333,56 @@ class GraduatedPriceData(BasePriceData):
         return total_cost
 
 
-class ModePriceData(BasePriceData):
+class ChannelPriceData(BasePriceData):
     """
-    Mode-based pricing that selects a sub-price by the request's resolved mode.
+    Channel-based pricing that selects a sub-price by the request's resolved channel.
 
-    The active mode is decided elsewhere — e.g. the gateway picks which keyed
-    ``upstream_access_config`` a request routes through (``"managed"``,
-    ``"byok"``, ``"byoe"``, …) — and threads it into
-    ``calculate_cost(..., mode=...)``. The matching entry in ``modes`` is
-    evaluated; when the mode is unknown or unset, the ``default`` mode is used.
+    The active channel is decided elsewhere — e.g. the gateway picks which keyed
+    ``upstream_access_config`` (upstream access channel) a request routes through
+    (``"managed"``, ``"byok"``, ``"byoe"``, …) — and threads it into
+    ``calculate_cost(..., channel=...)``. The matching entry in ``channels`` is
+    evaluated; when the channel is unknown or unset, the ``default`` channel is used.
 
     There is no special-casing on the consumer side: every pricing type accepts
-    an optional ``mode`` and a mode-independent price simply ignores it, so a
-    plain price behaves identically for all modes. Mode-dependent pricing is
+    an optional ``channel`` and a channel-independent price simply ignores it, so a
+    plain price behaves identically for all channels. Channel-dependent pricing is
     just this one extra optional pricing type.
 
-    Each ``modes`` value is itself any pricing object (flat, composite, tiered,
-    or even nested mode-based), validated lazily — mirroring how tiered pricing
+    Each ``channels`` value is itself any pricing object (flat, composite, tiered,
+    or even nested channel-based), validated lazily — mirroring how tiered pricing
     holds per-tier prices.
 
     Example:
         {
-            "type": "mode",
+            "type": "channel",
             "default": "managed",
-            "modes": {
+            "channels": {
                 "managed": {"type": "one_million_tokens", "input": "0.50", "output": "1.50"},
                 "byok": {"type": "constant", "price": "0"}
             }
         }
     """
 
-    type: Literal["mode"] = "mode"
+    type: Literal["channel"] = "channel"
 
     default: str = Field(
-        description="Mode key evaluated when the request's mode is unknown or unset. "
-        "Must be one of the keys in `modes`.",
+        description="Channel name evaluated when the request's channel is unknown or unset. "
+        "Must be one of the keys in `channels`.",
     )
 
-    modes: dict[str, dict[str, Any]] = Field(
-        description="Per-mode pricing keyed by mode name (e.g. 'managed', 'byok'). "
+    channels: dict[str, dict[str, Any]] = Field(
+        description="Per-channel pricing keyed by channel name (e.g. 'managed', 'byok'). "
         "Each value is a nested pricing object of any type.",
         min_length=1,
     )
 
     @model_validator(mode="after")
-    def _validate_default_and_price(self) -> ModePriceData:
+    def _validate_default_and_price(self) -> ChannelPriceData:
         """Require ``default`` to exist and auto-compute the nominal price from it."""
-        if self.default not in self.modes:
-            raise ValueError(f"default mode {self.default!r} is not defined in modes ({sorted(self.modes)})")
+        if self.default not in self.channels:
+            raise ValueError(f"default channel {self.default!r} is not defined in channels ({sorted(self.channels)})")
         if self.price is None:
-            self.price = _extract_nominal_price(self.modes[self.default])
+            self.price = _extract_nominal_price(self.channels[self.default])
         return self
 
     def calculate_cost(
@@ -1390,24 +1390,24 @@ class ModePriceData(BasePriceData):
         usage: UsageData,
         customer_charge: Decimal | None = None,
         request_count: int | None = None,
-        mode: str | None = None,
+        channel: str | None = None,
     ) -> Decimal:
-        """Evaluate the price for the resolved ``mode`` (falling back to ``default``).
+        """Evaluate the price for the resolved ``channel`` (falling back to ``default``).
 
         Args:
-            usage: Usage data passed to the selected mode's price.
+            usage: Usage data passed to the selected channel's price.
             customer_charge: Customer charge passed through.
             request_count: Request count passed through.
-            mode: The resolved mode; unknown/``None`` falls back to ``default``.
+            channel: The resolved channel; unknown/``None`` falls back to ``default``.
 
         Returns:
-            Cost from the selected mode's pricing.
+            Cost from the selected channel's pricing.
         """
-        selected = self.modes.get(mode) if mode is not None else None
+        selected = self.channels.get(channel) if channel is not None else None
         if selected is None:
-            selected = self.modes[self.default]
+            selected = self.channels[self.default]
         pricing = validate_pricing(selected)
-        return pricing.calculate_cost(usage, customer_charge, request_count, mode)
+        return pricing.calculate_cost(usage, customer_charge, request_count, channel)
 
 
 # Discriminated union of all pricing types
@@ -1430,7 +1430,7 @@ Pricing = Annotated[
     | TieredPriceData
     | GraduatedPriceData
     | ExprPriceData
-    | ModePriceData,
+    | ChannelPriceData,
     Field(discriminator="type"),
 ]
 
@@ -1454,7 +1454,7 @@ def validate_pricing(
     | TieredPriceData
     | GraduatedPriceData
     | ExprPriceData
-    | ModePriceData
+    | ChannelPriceData
 ):
     """
     Validate pricing dict and return the appropriate typed model.

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/models/service.py

@@ -116,7 +116,18 @@ class AccessInterfaceData(BaseModel):
 
 
 class UpstreamAccessConfigData(AccessInterfaceData):
-    """Upstream (seller-facing) access config data.
+    """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

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/schema/listing_v1.json

@@ -207,6 +207,78 @@
       "title": "AuthMethodEnum",
       "type": "string"
     },
+    "ChannelPriceData": {
+      "additionalProperties": false,
+      "description": "Channel-based pricing that selects a sub-price by the request's resolved channel.\n\nThe active channel is decided elsewhere — e.g. the gateway picks which keyed\n``upstream_access_config`` (upstream access channel) a request routes through\n(``\"managed\"``, ``\"byok\"``, ``\"byoe\"``, …) — and threads it into\n``calculate_cost(..., channel=...)``. The matching entry in ``channels`` is\nevaluated; when the channel is unknown or unset, the ``default`` channel is used.\n\nThere is no special-casing on the consumer side: every pricing type accepts\nan optional ``channel`` and a channel-independent price simply ignores it, so a\nplain price behaves identically for all channels. Channel-dependent pricing is\njust this one extra optional pricing type.\n\nEach ``channels`` value is itself any pricing object (flat, composite, tiered,\nor even nested channel-based), validated lazily — mirroring how tiered pricing\nholds per-tier prices.\n\nExample:\n    {\n        \"type\": \"channel\",\n        \"default\": \"managed\",\n        \"channels\": {\n            \"managed\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"},\n            \"byok\": {\"type\": \"constant\", \"price\": \"0\"}\n        }\n    }",
+      "properties": {
+        "channels": {
+          "additionalProperties": {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          "description": "Per-channel pricing keyed by channel name (e.g. 'managed', 'byok'). Each value is a nested pricing object of any type.",
+          "minProperties": 1,
+          "title": "Channels",
+          "type": "object"
+        },
+        "default": {
+          "description": "Channel name evaluated when the request's channel is unknown or unset. Must be one of the keys in `channels`.",
+          "title": "Default",
+          "type": "string"
+        },
+        "description": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Human-readable description of the pricing model",
+          "title": "Description"
+        },
+        "price": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Summary price for marketplace comparison and sorting. For simple pricing types this is the billing rate. For composite types (add, multiply, tiered, graduated) this is a seller-provided nominal value for marketplace display.",
+          "title": "Price"
+        },
+        "reference": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "URL to upstream provider's pricing page",
+          "title": "Reference"
+        },
+        "type": {
+          "const": "channel",
+          "default": "channel",
+          "title": "Type",
+          "type": "string"
+        }
+      },
+      "required": [
+        "default",
+        "channels"
+      ],
+      "title": "ChannelPriceData",
+      "type": "object"
+    },
     "ConstantPriceData": {
       "additionalProperties": false,
       "description": "Price data for a constant/fixed price.\n\nUsed for fixed fees, discounts, or adjustments that don't depend on usage.\nPrice can be positive (charge) or negative (discount/credit).",
@@ -964,78 +1036,6 @@
       "title": "MinPriceData",
       "type": "object"
     },
-    "ModePriceData": {
-      "additionalProperties": false,
-      "description": "Mode-based pricing that selects a sub-price by the request's resolved mode.\n\nThe active mode is decided elsewhere — e.g. the gateway picks which keyed\n``upstream_access_config`` a request routes through (``\"managed\"``,\n``\"byok\"``, ``\"byoe\"``, …) — and threads it into\n``calculate_cost(..., mode=...)``. The matching entry in ``modes`` is\nevaluated; when the mode is unknown or unset, the ``default`` mode is used.\n\nThere is no special-casing on the consumer side: every pricing type accepts\nan optional ``mode`` and a mode-independent price simply ignores it, so a\nplain price behaves identically for all modes. Mode-dependent pricing is\njust this one extra optional pricing type.\n\nEach ``modes`` value is itself any pricing object (flat, composite, tiered,\nor even nested mode-based), validated lazily — mirroring how tiered pricing\nholds per-tier prices.\n\nExample:\n    {\n        \"type\": \"mode\",\n        \"default\": \"managed\",\n        \"modes\": {\n            \"managed\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"},\n            \"byok\": {\"type\": \"constant\", \"price\": \"0\"}\n        }\n    }",
-      "properties": {
-        "default": {
-          "description": "Mode key evaluated when the request's mode is unknown or unset. Must be one of the keys in `modes`.",
-          "title": "Default",
-          "type": "string"
-        },
-        "description": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Human-readable description of the pricing model",
-          "title": "Description"
-        },
-        "modes": {
-          "additionalProperties": {
-            "additionalProperties": true,
-            "type": "object"
-          },
-          "description": "Per-mode pricing keyed by mode name (e.g. 'managed', 'byok'). Each value is a nested pricing object of any type.",
-          "minProperties": 1,
-          "title": "Modes",
-          "type": "object"
-        },
-        "price": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Summary price for marketplace comparison and sorting. For simple pricing types this is the billing rate. For composite types (add, multiply, tiered, graduated) this is a seller-provided nominal value for marketplace display.",
-          "title": "Price"
-        },
-        "reference": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "URL to upstream provider's pricing page",
-          "title": "Reference"
-        },
-        "type": {
-          "const": "mode",
-          "default": "mode",
-          "title": "Type",
-          "type": "string"
-        }
-      },
-      "required": [
-        "default",
-        "modes"
-      ],
-      "title": "ModePriceData",
-      "type": "object"
-    },
     "MultiplyPriceData": {
       "additionalProperties": false,
       "description": "Composite pricing that multiplies a base price by a factor.\n\nUseful for applying percentage-based adjustments to a base price.\n\nExample:\n    {\n        \"type\": \"multiply\",\n        \"factor\": \"0.70\",\n        \"base\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"}\n    }",
@@ -1932,6 +1932,7 @@
           "discriminator": {
             "mapping": {
               "add": "#/$defs/AddPriceData",
+              "channel": "#/$defs/ChannelPriceData",
               "constant": "#/$defs/ConstantPriceData",
               "expr": "#/$defs/ExprPriceData",
               "first": "#/$defs/FirstPriceData",
@@ -1939,7 +1940,6 @@
               "image": "#/$defs/ImagePriceData",
               "max": "#/$defs/MaxPriceData",
               "min": "#/$defs/MinPriceData",
-              "mode": "#/$defs/ModePriceData",
               "multiply": "#/$defs/MultiplyPriceData",
               "one_byte": "#/$defs/DataPriceData",
               "one_day": "#/$defs/TimePriceData",
@@ -2011,7 +2011,7 @@
               "$ref": "#/$defs/ExprPriceData"
             },
             {
-              "$ref": "#/$defs/ModePriceData"
+              "$ref": "#/$defs/ChannelPriceData"
             }
           ]
         },

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5}/src/unitysvc_core/schema/offering_v1.json

@@ -87,6 +87,78 @@
       "title": "AuthMethodEnum",
       "type": "string"
     },
+    "ChannelPriceData": {
+      "additionalProperties": false,
+      "description": "Channel-based pricing that selects a sub-price by the request's resolved channel.\n\nThe active channel is decided elsewhere — e.g. the gateway picks which keyed\n``upstream_access_config`` (upstream access channel) a request routes through\n(``\"managed\"``, ``\"byok\"``, ``\"byoe\"``, …) — and threads it into\n``calculate_cost(..., channel=...)``. The matching entry in ``channels`` is\nevaluated; when the channel is unknown or unset, the ``default`` channel is used.\n\nThere is no special-casing on the consumer side: every pricing type accepts\nan optional ``channel`` and a channel-independent price simply ignores it, so a\nplain price behaves identically for all channels. Channel-dependent pricing is\njust this one extra optional pricing type.\n\nEach ``channels`` value is itself any pricing object (flat, composite, tiered,\nor even nested channel-based), validated lazily — mirroring how tiered pricing\nholds per-tier prices.\n\nExample:\n    {\n        \"type\": \"channel\",\n        \"default\": \"managed\",\n        \"channels\": {\n            \"managed\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"},\n            \"byok\": {\"type\": \"constant\", \"price\": \"0\"}\n        }\n    }",
+      "properties": {
+        "channels": {
+          "additionalProperties": {
+            "additionalProperties": true,
+            "type": "object"
+          },
+          "description": "Per-channel pricing keyed by channel name (e.g. 'managed', 'byok'). Each value is a nested pricing object of any type.",
+          "minProperties": 1,
+          "title": "Channels",
+          "type": "object"
+        },
+        "default": {
+          "description": "Channel name evaluated when the request's channel is unknown or unset. Must be one of the keys in `channels`.",
+          "title": "Default",
+          "type": "string"
+        },
+        "description": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Human-readable description of the pricing model",
+          "title": "Description"
+        },
+        "price": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "Summary price for marketplace comparison and sorting. For simple pricing types this is the billing rate. For composite types (add, multiply, tiered, graduated) this is a seller-provided nominal value for marketplace display.",
+          "title": "Price"
+        },
+        "reference": {
+          "anyOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null,
+          "description": "URL to upstream provider's pricing page",
+          "title": "Reference"
+        },
+        "type": {
+          "const": "channel",
+          "default": "channel",
+          "title": "Type",
+          "type": "string"
+        }
+      },
+      "required": [
+        "default",
+        "channels"
+      ],
+      "title": "ChannelPriceData",
+      "type": "object"
+    },
     "ConstantPriceData": {
       "additionalProperties": false,
       "description": "Price data for a constant/fixed price.\n\nUsed for fixed fees, discounts, or adjustments that don't depend on usage.\nPrice can be positive (charge) or negative (discount/credit).",
@@ -834,78 +906,6 @@
       "title": "MinPriceData",
       "type": "object"
     },
-    "ModePriceData": {
-      "additionalProperties": false,
-      "description": "Mode-based pricing that selects a sub-price by the request's resolved mode.\n\nThe active mode is decided elsewhere — e.g. the gateway picks which keyed\n``upstream_access_config`` a request routes through (``\"managed\"``,\n``\"byok\"``, ``\"byoe\"``, …) — and threads it into\n``calculate_cost(..., mode=...)``. The matching entry in ``modes`` is\nevaluated; when the mode is unknown or unset, the ``default`` mode is used.\n\nThere is no special-casing on the consumer side: every pricing type accepts\nan optional ``mode`` and a mode-independent price simply ignores it, so a\nplain price behaves identically for all modes. Mode-dependent pricing is\njust this one extra optional pricing type.\n\nEach ``modes`` value is itself any pricing object (flat, composite, tiered,\nor even nested mode-based), validated lazily — mirroring how tiered pricing\nholds per-tier prices.\n\nExample:\n    {\n        \"type\": \"mode\",\n        \"default\": \"managed\",\n        \"modes\": {\n            \"managed\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"},\n            \"byok\": {\"type\": \"constant\", \"price\": \"0\"}\n        }\n    }",
-      "properties": {
-        "default": {
-          "description": "Mode key evaluated when the request's mode is unknown or unset. Must be one of the keys in `modes`.",
-          "title": "Default",
-          "type": "string"
-        },
-        "description": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Human-readable description of the pricing model",
-          "title": "Description"
-        },
-        "modes": {
-          "additionalProperties": {
-            "additionalProperties": true,
-            "type": "object"
-          },
-          "description": "Per-mode pricing keyed by mode name (e.g. 'managed', 'byok'). Each value is a nested pricing object of any type.",
-          "minProperties": 1,
-          "title": "Modes",
-          "type": "object"
-        },
-        "price": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Summary price for marketplace comparison and sorting. For simple pricing types this is the billing rate. For composite types (add, multiply, tiered, graduated) this is a seller-provided nominal value for marketplace display.",
-          "title": "Price"
-        },
-        "reference": {
-          "anyOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "URL to upstream provider's pricing page",
-          "title": "Reference"
-        },
-        "type": {
-          "const": "mode",
-          "default": "mode",
-          "title": "Type",
-          "type": "string"
-        }
-      },
-      "required": [
-        "default",
-        "modes"
-      ],
-      "title": "ModePriceData",
-      "type": "object"
-    },
     "MultiplyPriceData": {
       "additionalProperties": false,
       "description": "Composite pricing that multiplies a base price by a factor.\n\nUseful for applying percentage-based adjustments to a base price.\n\nExample:\n    {\n        \"type\": \"multiply\",\n        \"factor\": \"0.70\",\n        \"base\": {\"type\": \"one_million_tokens\", \"input\": \"0.50\", \"output\": \"1.50\"}\n    }",
@@ -1789,7 +1789,7 @@
     },
     "UpstreamAccessConfigData": {
       "additionalProperties": true,
-      "description": "Upstream (seller-facing) access config data.\n\nExtends AccessInterfaceData with extra=\"allow\" to support protocol-specific\nconfiguration fields (e.g., S3 bucket/region, SMTP host/port) that the\ngateway needs to reach the upstream service.",
+      "description": "One upstream access channel — a named entry in ``upstream_access_config``.\n\nEach channel is a complete way for the gateway to reach the upstream: a wire\nprotocol (``access_method``), endpoint (``base_url``), credential (``api_key``),\nrouting key, and rate-limit/quality restrictions. A service may declare several\nchannels (keyed by free-form channel name, e.g. ``\"managed\"``, ``\"byok\"``,\n``\"managed-eu\"``); the gateway selects one per request.\n\nThe channel's *type* is derived from its credential/endpoint provenance:\n``managed`` (seller's key, ``${ secrets.* }``), ``byok`` (customer's key,\n``${ customer_secrets.* }``), or ``byoe`` (customer's key + customer-templated\n``base_url``).\n\nExtends AccessInterfaceData with extra=\"allow\" to support protocol-specific\nconfiguration fields (e.g., S3 bucket/region, SMTP host/port) that the\ngateway needs to reach the upstream service.",
       "properties": {
         "access_method": {
           "$ref": "#/$defs/AccessMethodEnum",
@@ -2014,6 +2014,7 @@
           "discriminator": {
             "mapping": {
               "add": "#/$defs/AddPriceData",
+              "channel": "#/$defs/ChannelPriceData",
               "constant": "#/$defs/ConstantPriceData",
               "expr": "#/$defs/ExprPriceData",
               "first": "#/$defs/FirstPriceData",
@@ -2021,7 +2022,6 @@
               "image": "#/$defs/ImagePriceData",
               "max": "#/$defs/MaxPriceData",
               "min": "#/$defs/MinPriceData",
-              "mode": "#/$defs/ModePriceData",
               "multiply": "#/$defs/MultiplyPriceData",
               "one_byte": "#/$defs/DataPriceData",
               "one_day": "#/$defs/TimePriceData",
@@ -2093,7 +2093,7 @@
               "$ref": "#/$defs/ExprPriceData"
             },
             {
-              "$ref": "#/$defs/ModePriceData"
+              "$ref": "#/$defs/ChannelPriceData"
             }
           ]
         },
@@ -2153,7 +2153,7 @@
       "additionalProperties": {
         "$ref": "#/$defs/UpstreamAccessConfigData"
       },
-      "description": "Upstream access interfaces, keyed by name",
+      "description": "Upstream access channels, keyed by channel name",
       "title": "Upstream Access Config",
       "type": "object"
     }

{unitysvc_core-0.2.4 → unitysvc_core-0.2.5/src/unitysvc_core.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitysvc-core
-Version: 0.2.4
+Version: 0.2.5
 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.4 → unitysvc_core-0.2.5}/tests/test_pricing.py

@@ -1808,67 +1808,67 @@ class TestNominalPriceAutoCompute:
         assert pricing.price == "9.00"
 
 
-class TestModePriceData:
-    """Tests for mode-based pricing (select a sub-price by resolved mode)."""
+class TestChannelPriceData:
+    """Tests for channel-based pricing (select a sub-price by resolved channel)."""
 
     def _managed_byok(self) -> dict:
         """Canonical managed+byok: managed is paid, byok is free.
 
-        Uses ``constant`` sub-prices so the tests exercise mode *selection*
+        Uses ``constant`` sub-prices so the tests exercise channel *selection*
         independently of any usage-metric math.
         """
         return {
-            "type": "mode",
+            "type": "channel",
             "default": "managed",
-            "modes": {
+            "channels": {
                 "managed": {"type": "constant", "price": "6.00"},
                 "byok": {"type": "constant", "price": "0"},
             },
         }
 
-    def test_selects_matching_mode(self) -> None:
-        """The resolved mode picks that mode's price."""
+    def test_selects_matching_channel(self) -> None:
+        """The resolved channel picks that channel's price."""
         pricing = validate_pricing(self._managed_byok())
         usage = UsageData()
 
-        assert pricing.calculate_cost(usage, mode="managed") == Decimal("6.00")
-        assert pricing.calculate_cost(usage, mode="byok") == Decimal("0")
+        assert pricing.calculate_cost(usage, channel="managed") == Decimal("6.00")
+        assert pricing.calculate_cost(usage, channel="byok") == Decimal("0")
 
-    def test_unknown_mode_falls_back_to_default(self) -> None:
-        """An unrecognised mode evaluates the default mode."""
+    def test_unknown_channel_falls_back_to_default(self) -> None:
+        """An unrecognised channel evaluates the default channel."""
         pricing = validate_pricing(self._managed_byok())
 
-        assert pricing.calculate_cost(UsageData(), mode="nonexistent") == Decimal("6.00")
+        assert pricing.calculate_cost(UsageData(), channel="nonexistent") == Decimal("6.00")
 
-    def test_none_mode_falls_back_to_default(self) -> None:
-        """No mode (the common case for non-mode-aware callers) uses the default."""
+    def test_none_channel_falls_back_to_default(self) -> None:
+        """No channel (the common case for non-channel-aware callers) uses the default."""
         pricing = validate_pricing(self._managed_byok())
 
         assert pricing.calculate_cost(UsageData()) == Decimal("6.00")
 
-    def test_non_mode_price_ignores_mode(self) -> None:
-        """A plain (mode-independent) price yields the same cost for every mode."""
+    def test_non_channel_price_ignores_channel(self) -> None:
+        """A plain (channel-independent) price yields the same cost for every channel."""
         pricing = validate_pricing({"type": "constant", "price": "6.00"})
         usage = UsageData()
 
         base = pricing.calculate_cost(usage)
-        assert pricing.calculate_cost(usage, mode="byok") == base
-        assert pricing.calculate_cost(usage, mode="managed") == base
+        assert pricing.calculate_cost(usage, channel="byok") == base
+        assert pricing.calculate_cost(usage, channel="managed") == base
         assert base == Decimal("6.00")
 
     def test_default_must_exist(self) -> None:
-        """`default` must name one of the modes."""
-        with pytest.raises(ValueError, match="default mode"):
+        """`default` must name one of the channels."""
+        with pytest.raises(ValueError, match="default channel"):
             validate_pricing(
                 {
-                    "type": "mode",
+                    "type": "channel",
                     "default": "missing",
-                    "modes": {"managed": {"type": "constant", "price": "1"}},
+                    "channels": {"managed": {"type": "constant", "price": "1"}},
                 }
             )
 
-    def test_nominal_price_from_default_mode(self) -> None:
-        """The summary price auto-computes from the default mode when unset."""
+    def test_nominal_price_from_default_channel(self) -> None:
+        """The summary price auto-computes from the default channel when unset."""
         pricing = validate_pricing(self._managed_byok())
         assert pricing.price == "6.00"  # managed (default) summary price
 
@@ -1879,16 +1879,16 @@ class TestModePriceData:
         pricing = validate_pricing(data)
         assert pricing.price == "1.50"
 
-    def test_mode_threads_through_composite(self) -> None:
-        """`mode` propagates into nested children (e.g. a mode price inside `add`)."""
+    def test_channel_threads_through_composite(self) -> None:
+        """`channel` propagates into nested children (e.g. a channel price inside `add`)."""
         pricing = validate_pricing(
             {
                 "type": "add",
                 "prices": [
                     {
-                        "type": "mode",
+                        "type": "channel",
                         "default": "managed",
-                        "modes": {
+                        "channels": {
                             "managed": {"type": "constant", "price": "10"},
                             "byok": {"type": "constant", "price": "0"},
                         },
@@ -1899,17 +1899,17 @@ class TestModePriceData:
         )
         usage = UsageData()
 
-        # byok: 0 (mode price) + 1.00 (fee); managed: 10 + 1.00
-        assert pricing.calculate_cost(usage, mode="byok") == Decimal("1.00")
-        assert pricing.calculate_cost(usage, mode="managed") == Decimal("11.00")
+        # byok: 0 (channel price) + 1.00 (fee); managed: 10 + 1.00
+        assert pricing.calculate_cost(usage, channel="byok") == Decimal("1.00")
+        assert pricing.calculate_cost(usage, channel="managed") == Decimal("11.00")
 
-    def test_mode_price_can_nest_tiered(self) -> None:
-        """A mode's pricing may itself be any pricing type (here: tiered)."""
+    def test_channel_price_can_nest_tiered(self) -> None:
+        """A channel's pricing may itself be any pricing type (here: tiered)."""
         pricing = validate_pricing(
             {
-                "type": "mode",
+                "type": "channel",
                 "default": "managed",
-                "modes": {
+                "channels": {
                     "managed": {
                         "type": "tiered",
                         "based_on": "request_count",
@@ -1924,6 +1924,6 @@ class TestModePriceData:
         )
         usage = UsageData()
 
-        assert pricing.calculate_cost(usage, request_count=10, mode="managed") == Decimal("5")
-        assert pricing.calculate_cost(usage, request_count=10_000, mode="managed") == Decimal("50")
-        assert pricing.calculate_cost(usage, request_count=10_000, mode="byok") == Decimal("0")
+        assert pricing.calculate_cost(usage, request_count=10, channel="managed") == Decimal("5")
+        assert pricing.calculate_cost(usage, request_count=10_000, channel="managed") == Decimal("50")
+        assert pricing.calculate_cost(usage, request_count=10_000, channel="byok") == Decimal("0")