runapi-core 0.2.4__tar.gz → 0.3.0__tar.gz

{runapi_core-0.2.4 → runapi_core-0.3.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: runapi-core
-Version: 0.2.4
+Version: 0.3.0
 Summary: RunAPI core SDK for JavaScript, Python, Ruby, Go, Java, and PHP
 Project-URL: Homepage, https://runapi.ai/models
 Project-URL: Documentation, https://runapi.ai/docs#runapi-sdks
 Project-URL: Source, https://github.com/runapi-ai/core-sdk
 Project-URL: Issues, https://github.com/runapi-ai/core-sdk/issues
 Project-URL: Changelog, https://github.com/runapi-ai/core-sdk/blob/main/CHANGELOG.md
-Project-URL: Release Notes, https://github.com/runapi-ai/core-sdk/releases/tag/python%2Fv0.2.4
+Project-URL: Release Notes, https://github.com/runapi-ai/core-sdk/releases/tag/python%2Fv0.3.0
 Author-email: RunAPI <contact@runapi.ai>
 License-Expression: Apache-2.0
 Keywords: api,core,golang,gradle,java,maven,pypi,python,ruby,runapi,runapi-ai,sdk,typescript
@@ -27,7 +27,7 @@ pip install runapi-core
 
 ## Notes
 
-Use the core package for common client options, error classes, request helpers, file uploads, and task polling behavior that Provider Clients share. Configure it globally or per client:
+Use the core package for common client options, error classes, request helpers, file uploads, live pricing, account resources, and task polling behavior that Provider Clients share. Configure it globally or per client:
 
 ```python
 import runapi.core as runapi
@@ -39,6 +39,8 @@ runapi.configure(api_key="sk-...")  # or set RUNAPI_API_KEY in the environment
 
 RunAPI accepts an optional `X-Client-Request-Id` header on public API calls. Use printable ASCII values up to 512 characters. Accepted values are echoed in the response and stored with the RunAPI task for support and reconciliation.
 
+Task-creation calls also accept an optional opaque `Idempotency-Key` up to 512 characters. Generate one value per logical task and reuse it only with identical input after an unknown result. Reusing the value with different input returns `409 Conflict`; do not derive it from `X-Client-Request-Id`.
+
 High-level Python Provider Client resource methods accept per-request options and keep response headers on the returned model object. This example uses the Suno Provider Client; install `runapi-suno` to run it.
 
 ```python
@@ -49,7 +51,10 @@ from runapi.suno import SunoClient
 
 client = SunoClient(api_key=os.environ["RUNAPI_API_KEY"])
 options = RequestOptions(
-    headers={"X-Client-Request-Id": "order-123"},
+    headers={
+        "X-Client-Request-Id": "order-123",
+        "Idempotency-Key": "opaque-logical-task-123",
+    },
 )
 
 response = client.text_to_music.create(
@@ -76,6 +81,30 @@ print(uploaded.url)
 
 Public SDK docs live at https://runapi.ai/docs#runapi-sdks and the model catalog lives at https://runapi.ai/models.
 
+## Universal resources
+
+Every Provider Client exposes `files`, `account`, and `pricing` through one shared HTTP client. `pricing.list_schedules()` reads the current schedule, and `pricing.create_quote()` estimates a reservation without creating a Task. The schedule and ordinary quote calls do not require an API key; a quote that uses an existing Task as pricing context requires the key for that Task's Account.
+
+```python
+from runapi.core import RequestOptions
+from runapi.flux import FluxClient
+
+client = FluxClient(api_key="sk-...")
+schedules = client.pricing.list_schedules(
+    service="flux",
+    action="text_to_image",
+    options=RequestOptions(headers={"If-None-Match": '"previous-etag"'}),
+)
+quote = client.pricing.create_quote(
+    service="flux",
+    action="text_to_image",
+    model="flux-pro",
+    params={"prompt": "A glass observatory"},
+)
+```
+
+Task responses expose persisted billing facts at `response.billing`: `reservation`, `settlement`, and `refund` are typed objects when recorded and `None` when the historical fact is absent. These facts describe that Task and are not recalculated from the current schedule.
+
 ## License
 
 Licensed under the Apache License, Version 2.0.

{runapi_core-0.2.4 → runapi_core-0.3.0}/README.md

@@ -10,7 +10,7 @@ pip install runapi-core
 
 ## Notes
 
-Use the core package for common client options, error classes, request helpers, file uploads, and task polling behavior that Provider Clients share. Configure it globally or per client:
+Use the core package for common client options, error classes, request helpers, file uploads, live pricing, account resources, and task polling behavior that Provider Clients share. Configure it globally or per client:
 
 ```python
 import runapi.core as runapi
@@ -22,6 +22,8 @@ runapi.configure(api_key="sk-...")  # or set RUNAPI_API_KEY in the environment
 
 RunAPI accepts an optional `X-Client-Request-Id` header on public API calls. Use printable ASCII values up to 512 characters. Accepted values are echoed in the response and stored with the RunAPI task for support and reconciliation.
 
+Task-creation calls also accept an optional opaque `Idempotency-Key` up to 512 characters. Generate one value per logical task and reuse it only with identical input after an unknown result. Reusing the value with different input returns `409 Conflict`; do not derive it from `X-Client-Request-Id`.
+
 High-level Python Provider Client resource methods accept per-request options and keep response headers on the returned model object. This example uses the Suno Provider Client; install `runapi-suno` to run it.
 
 ```python
@@ -32,7 +34,10 @@ from runapi.suno import SunoClient
 
 client = SunoClient(api_key=os.environ["RUNAPI_API_KEY"])
 options = RequestOptions(
-    headers={"X-Client-Request-Id": "order-123"},
+    headers={
+        "X-Client-Request-Id": "order-123",
+        "Idempotency-Key": "opaque-logical-task-123",
+    },
 )
 
 response = client.text_to_music.create(
@@ -59,6 +64,30 @@ print(uploaded.url)
 
 Public SDK docs live at https://runapi.ai/docs#runapi-sdks and the model catalog lives at https://runapi.ai/models.
 
+## Universal resources
+
+Every Provider Client exposes `files`, `account`, and `pricing` through one shared HTTP client. `pricing.list_schedules()` reads the current schedule, and `pricing.create_quote()` estimates a reservation without creating a Task. The schedule and ordinary quote calls do not require an API key; a quote that uses an existing Task as pricing context requires the key for that Task's Account.
+
+```python
+from runapi.core import RequestOptions
+from runapi.flux import FluxClient
+
+client = FluxClient(api_key="sk-...")
+schedules = client.pricing.list_schedules(
+    service="flux",
+    action="text_to_image",
+    options=RequestOptions(headers={"If-None-Match": '"previous-etag"'}),
+)
+quote = client.pricing.create_quote(
+    service="flux",
+    action="text_to_image",
+    model="flux-pro",
+    params={"prompt": "A glass observatory"},
+)
+```
+
+Task responses expose persisted billing facts at `response.billing`: `reservation`, `settlement`, and `refund` are typed objects when recorded and `None` when the historical fact is absent. These facts describe that Task and are not recalculated from the current schedule.
+
 ## License
 
 Licensed under the Apache License, Version 2.0.

{runapi_core-0.2.4 → runapi_core-0.3.0}/pyproject.toml

@@ -19,7 +19,7 @@ Documentation = "https://runapi.ai/docs#runapi-sdks"
 Source = "https://github.com/runapi-ai/core-sdk"
 Issues = "https://github.com/runapi-ai/core-sdk/issues"
 Changelog = "https://github.com/runapi-ai/core-sdk/blob/main/CHANGELOG.md"
-"Release Notes" = "https://github.com/runapi-ai/core-sdk/releases/tag/python%2Fv0.2.4"
+"Release Notes" = "https://github.com/runapi-ai/core-sdk/releases/tag/python%2Fv0.3.0"
 
 [tool.hatch.version]
 path = "src/runapi/core/version.py"

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/__init__.py

@@ -5,7 +5,8 @@ client shared by every per-model-line package.
 """
 
 from . import config, errors, polling
-from .auth import resolve_api_key
+from .auth import resolve_api_key, resolve_optional_api_key
+from .account import Account, AccountBalanceResponse, AccountInfoResponse, AccountRecord
 from .config import configure
 from .contract_gen import CONTRACT
 from .errors import (
@@ -26,11 +27,23 @@ from .errors import (
 )
 from .files import FilesClient, UploadResponse
 from .http_client import HttpClient
-from .models import BaseModel, DynamicModel, TaskResponse, optional, required
+from .models import (
+    BaseModel,
+    BillingRefund,
+    BillingReservation,
+    BillingSettlement,
+    DynamicModel,
+    TaskBillingFacts,
+    TaskResponse,
+    optional,
+    required,
+)
 from .multipart import MultipartBody, MultipartFile
 from .options import ClientOptions, PollingOptions, RequestOptions
 from .response import ApiResponse, ResponseHeaders
 from .resource import Resource
+from .pricing import PriceQuote, PriceQuoteResponse, PriceSchedule, PriceScheduleListResponse, Pricing, PricingClient
+from .provider_client import ProviderClient
 from .version import __version__
 
 __all__ = [
@@ -41,6 +54,11 @@ __all__ = [
     "polling",
     "CONTRACT",
     "resolve_api_key",
+    "resolve_optional_api_key",
+    "Account",
+    "AccountRecord",
+    "AccountInfoResponse",
+    "AccountBalanceResponse",
     "Error",
     "AuthenticationError",
     "InsufficientCreditsError",
@@ -63,6 +81,10 @@ __all__ = [
     "BaseModel",
     "DynamicModel",
     "TaskResponse",
+    "BillingReservation",
+    "BillingSettlement",
+    "BillingRefund",
+    "TaskBillingFacts",
     "required",
     "optional",
     "MultipartBody",
@@ -71,4 +93,11 @@ __all__ = [
     "Resource",
     "FilesClient",
     "UploadResponse",
+    "Pricing",
+    "PricingClient",
+    "PriceSchedule",
+    "PriceScheduleListResponse",
+    "PriceQuote",
+    "PriceQuoteResponse",
+    "ProviderClient",
 ]

runapi_core-0.3.0/src/runapi/core/account.py

@@ -0,0 +1,42 @@
+"""Account resources available from every Provider Client."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .models import BaseModel, required
+from .options import RequestOptions
+from .resource import Resource
+
+
+class AccountRecord(BaseModel):
+    id = required(int)
+    name = required(str)
+
+
+class AccountInfoResponse(BaseModel):
+    id = required(int)
+    name = required(str)
+    email = required(str)
+    account = required(AccountRecord)
+
+
+class AccountBalanceResponse(BaseModel):
+    balance_cents = required(int)
+    paid_balance_cents = required(int)
+    bonus_balance_cents = required(int)
+    spent_cents_today = required(int)
+    spent_cents_total = required(int)
+
+
+class Account(Resource):
+    """Read the authenticated user's account information and balance."""
+
+    INFO_ENDPOINT = "/api/v1/me"
+    BALANCE_ENDPOINT = "/api/v1/me/balance"
+
+    def info(self, options: Optional[RequestOptions] = None) -> AccountInfoResponse:
+        return self._request("get", self.INFO_ENDPOINT, options=options, response_class=AccountInfoResponse)
+
+    def balance(self, options: Optional[RequestOptions] = None) -> AccountBalanceResponse:
+        return self._request("get", self.BALANCE_ENDPOINT, options=options, response_class=AccountBalanceResponse)

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/auth.py

@@ -23,12 +23,17 @@ def resolve_api_key(explicit: Optional[str] = None) -> str:
     All sources are trimmed; blank values are treated as missing. Raises
     :class:`AuthenticationError` when no source yields a value.
     """
-    resolved = _normalize(explicit) or _normalize(config.api_key) or _normalize(os.environ.get(ENV_VAR_NAME))
+    resolved = resolve_optional_api_key(explicit)
     if not resolved:
         raise AuthenticationError(MISSING_KEY_MESSAGE)
     return resolved
 
 
+def resolve_optional_api_key(explicit: Optional[str] = None) -> Optional[str]:
+    """Resolve an API key without requiring one for public resources."""
+    return _normalize(explicit) or _normalize(config.api_key) or _normalize(os.environ.get(ENV_VAR_NAME))
+
+
 def _normalize(value: Optional[str]) -> Optional[str]:
     if not isinstance(value, str):
         return None

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/contract_gen.py

@@ -703,7 +703,7 @@ CONTRACT = {
         }
     },
     "kling/motion-control": {
-        "models": ["kling-3.0"],
+        "models": ["kling-3.0", "kling-v2.6"],
         "fields_by_model": {
             "kling-3.0": {
                 "background_source": {
@@ -715,6 +715,14 @@ CONTRACT = {
                 "output_resolution": {
                     "enum": ["720p", "1080p"]
                 }
+            },
+            "kling-v2.6": {
+                "character_orientation": {
+                    "enum": ["video", "image"]
+                },
+                "output_resolution": {
+                    "enum": ["720p", "1080p"]
+                }
             }
         }
     },

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/files.py

@@ -34,7 +34,10 @@ class FilesClient(Resource):
 
     RESPONSE_CLASS = UploadResponse
 
-    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+    def __init__(self, api_key: Optional[str] = None, *, http: Any = None, **options: Any) -> None:
+        if http is not None:
+            super().__init__(http)
+            return
         resolved_api_key = auth.resolve_api_key(api_key)
         client_options = ClientOptions(api_key=resolved_api_key, **options)
         http = client_options.http_client or HttpClient(client_options)

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/http_client.py

@@ -28,15 +28,17 @@ class HttpClient:
 
     def __init__(self, options: ClientOptions, *, transport: Optional[httpx.BaseTransport] = None) -> None:
         self._options = options
+        headers = {
+            "Accept": "application/json",
+            "User-Agent": constants.SDK_USER_AGENT,
+        }
+        if options.api_key:
+            headers["Authorization"] = f"Bearer {options.api_key}"
         self._client = httpx.Client(
             base_url=options.base_url,
             timeout=options.timeout,
             transport=transport,
-            headers={
-                "Authorization": f"Bearer {options.api_key}",
-                "Accept": "application/json",
-                "User-Agent": constants.SDK_USER_AGENT,
-            },
+            headers=headers,
         )
         # A bare client for direct uploads: the pre-authorized upload URL lives
         # outside the API host and must not receive the API key.
@@ -77,6 +79,9 @@ class HttpClient:
                 except httpx.TransportError as exc:
                     raise NetworkError(str(exc))
 
+                if response.status_code == 304:
+                    return None
+
                 if response.is_success:
                     body = self._parse_body(response.text)
                     if body is None:

{runapi_core-0.2.4 → runapi_core-0.3.0}/src/runapi/core/models.py

@@ -263,3 +263,23 @@ class TaskResponse(BaseModel):
     id = optional(str)
     status = optional(str)
     error = optional(str)
+    billing = optional(lambda: TaskBillingFacts)
+
+
+class BillingReservation(BaseModel):
+    amount_cents = required(int)
+
+
+class BillingSettlement(BaseModel):
+    charged_amount_cents = required(int)
+    amount_micro_cents = required(int)
+
+
+class BillingRefund(BaseModel):
+    refunded_at = required(str)
+
+
+class TaskBillingFacts(BaseModel):
+    reservation = optional(BillingReservation)
+    settlement = optional(BillingSettlement)
+    refund = optional(BillingRefund)

runapi_core-0.3.0/src/runapi/core/pricing.py

@@ -0,0 +1,92 @@
+"""Live Pricing API resources."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .auth import resolve_optional_api_key
+from .models import BaseModel, optional, required
+from .http_client import HttpClient
+from .options import ClientOptions, RequestOptions
+from .resource import Resource
+
+
+class PriceSchedule(BaseModel):
+    service = required(str)
+    action = required(str)
+    model = optional(str)
+    pricing_status = required(str)
+    catalog_status = required(str)
+    currency = required(str)
+    billing_unit = optional(str)
+    billing_strategy = optional(str)
+    unit_price_cents = optional(int)
+    input_price_per_1m_cents = optional(int)
+    output_price_per_1m_cents = optional(int)
+    cache_read_price_per_1m_cents = optional(int)
+    cache_write_5m_price_per_1m_cents = optional(int)
+    cache_write_1h_price_per_1m_cents = optional(int)
+    billing_config = optional()
+
+
+class PriceScheduleListResponse(BaseModel):
+    as_of = required(str)
+    price_schedules = required([PriceSchedule])
+
+
+class PriceQuote(BaseModel):
+    service = required(str)
+    action = required(str)
+    model = optional(str)
+    pricing_status = required(str)
+    currency = required(str)
+    reservation_amount_cents = required(int)
+    estimate_basis = required(str)
+    as_of = required(str)
+
+
+class PriceQuoteResponse(BaseModel):
+    price_quote = required(PriceQuote)
+
+
+class Pricing(Resource):
+    """Read current price schedules and create reservation estimates."""
+
+    SCHEDULES_ENDPOINT = "/api/v1/price_schedules"
+    QUOTES_ENDPOINT = "/api/v1/price_quotes"
+
+    def list_schedules(
+        self,
+        service: Optional[str] = None,
+        action: Optional[str] = None,
+        model: Optional[str] = None,
+        options: Optional[RequestOptions] = None,
+    ) -> Optional[PriceScheduleListResponse]:
+        filters = self._compact_params({"service": service, "action": action, "model": model})
+        path = self.SCHEDULES_ENDPOINT
+        if filters:
+            from urllib.parse import urlencode
+
+            path = f"{path}?{urlencode(filters)}"
+        return self._request("get", path, options=options, response_class=PriceScheduleListResponse)
+
+    def create_quote(
+        self,
+        service: str,
+        action: str,
+        model: Optional[str] = None,
+        params: Optional[dict[str, Any]] = None,
+        options: Optional[RequestOptions] = None,
+    ) -> PriceQuoteResponse:
+        body = {"service": service, "action": action, "model": model, "params": params}
+        return self._request(
+            "post", self.QUOTES_ENDPOINT, body=self._compact_params(body), options=options, response_class=PriceQuoteResponse
+        )
+
+
+class PricingClient(Pricing):
+    """Standalone Pricing client with optional API authentication."""
+
+    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+        client_options = ClientOptions(api_key=resolve_optional_api_key(api_key), **options)
+        super().__init__(client_options.http_client or HttpClient(client_options))

runapi_core-0.3.0/src/runapi/core/provider_client.py

@@ -0,0 +1,24 @@
+"""Shared foundation for model-line Provider Clients."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .account import Account
+from .auth import resolve_api_key
+from .files import FilesClient
+from .http_client import HttpClient
+from .options import ClientOptions
+from .pricing import Pricing
+
+
+class ProviderClient:
+    """Resolve auth and expose universal resources on every model-line client."""
+
+    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+        resolved_api_key = resolve_api_key(api_key)
+        client_options = ClientOptions(api_key=resolved_api_key, **options)
+        self._http = client_options.http_client or HttpClient(client_options)
+        self.files = FilesClient(http=self._http)
+        self.account = Account(self._http)
+        self.pricing = Pricing(self._http)

runapi_core-0.3.0/src/runapi/core/version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

runapi_core-0.3.0/tests/test_account.py

@@ -0,0 +1,39 @@
+from runapi.core import Account, AccountBalanceResponse, AccountInfoResponse
+
+
+class FakeHttp:
+    def __init__(self, *responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body, options))
+        return self._responses.pop(0)
+
+
+def test_info_returns_typed_account_details():
+    http = FakeHttp({"id": 1, "name": "Developer", "email": "developer@example.com", "account": {"id": 2, "name": "Acme"}})
+
+    result = Account(http).info()
+
+    assert isinstance(result, AccountInfoResponse)
+    assert result.account.name == "Acme"
+    assert http.calls == [("get", "/api/v1/me", None, None)]
+
+
+def test_balance_returns_typed_balance_details():
+    http = FakeHttp(
+        {
+            "balance_cents": 5000,
+            "paid_balance_cents": 4000,
+            "bonus_balance_cents": 1000,
+            "spent_cents_today": 100,
+            "spent_cents_total": 2000,
+        }
+    )
+
+    result = Account(http).balance()
+
+    assert isinstance(result, AccountBalanceResponse)
+    assert result.balance_cents == 5000
+    assert http.calls == [("get", "/api/v1/me/balance", None, None)]

{runapi_core-0.2.4 → runapi_core-0.3.0}/tests/test_auth.py

@@ -57,6 +57,10 @@ def test_raises_when_no_source():
         auth.resolve_api_key(None)
 
 
+def test_optional_resolution_returns_none_when_no_source():
+    assert auth.resolve_optional_api_key(None) is None
+
+
 def test_configure_sets_global(monkeypatch):
     config.configure(api_key="configured-key")
     assert auth.resolve_api_key(None) == "configured-key"

{runapi_core-0.2.4 → runapi_core-0.3.0}/tests/test_files.py

@@ -50,6 +50,14 @@ def test_requires_exactly_one_source():
         client.create(file="x", source="y")
 
 
+def test_accepts_an_existing_http_client_without_resolving_auth_again():
+    fake = FakeHttp(UPLOAD)
+
+    client = FilesClient(http=fake)
+
+    assert client._http is fake
+
+
 def test_create_with_remote_source_sends_url_source_object():
     fake = FakeHttp(UPLOAD)
     client = FilesClient(api_key="k", http_client=fake)

{runapi_core-0.2.4 → runapi_core-0.3.0}/tests/test_http_client.py

@@ -93,6 +93,19 @@ def test_sends_bearer_and_user_agent():
     assert captured["ua"] == constants.SDK_USER_AGENT
 
 
+def test_omits_authorization_header_without_an_api_key():
+    captured = {}
+
+    def handler(request):
+        captured["auth"] = request.headers.get("authorization")
+        return httpx.Response(200, json={})
+
+    options = ClientOptions(api_key=None, base_url="https://runapi.ai")
+    HttpClient(options, transport=httpx.MockTransport(handler)).request("get", "/api/v1/price_schedules")
+
+    assert captured["auth"] is None
+
+
 def test_sends_json_body_for_post():
     captured = {}
 

{runapi_core-0.2.4 → runapi_core-0.3.0}/tests/test_models.py

@@ -1,6 +1,6 @@
 import pytest
 
-from runapi.core import BaseModel, DynamicModel, optional, required
+from runapi.core import BaseModel, DynamicModel, TaskBillingFacts, TaskResponse, optional, required
 from runapi.core.errors import ValidationError
 
 
@@ -117,3 +117,16 @@ def test_response_headers_stay_outside_serialized_body():
     assert model.response_header("x-runapi-task-id") == "task-ref-1"
     assert model.runapi_task_id == "task-ref-1"
     assert model.to_dict() == {"id": "abc"}
+
+
+def test_task_response_coerces_typed_billing_facts_and_preserves_unknown_fields():
+    response = TaskResponse(
+        {
+            "id": "task_1",
+            "billing": {"reservation": {"amount_cents": 5}, "future_fact": "retained"},
+        }
+    )
+
+    assert isinstance(response.billing, TaskBillingFacts)
+    assert response.billing.reservation.amount_cents == 5
+    assert response.billing.future_fact == "retained"

runapi_core-0.3.0/tests/test_pricing.py

@@ -0,0 +1,119 @@
+import httpx
+import pytest
+
+from runapi.core import ApiResponse, ClientOptions, HttpClient, PriceQuoteResponse, PriceScheduleListResponse, Pricing, PricingClient, RequestOptions, config
+
+
+class FakeHttp:
+    def __init__(self, *responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body, options))
+        return self._responses.pop(0)
+
+
+SCHEDULE = {
+    "service": "nano_banana",
+    "action": "text_to_image",
+    "model": "nano-banana",
+    "pricing_status": "available",
+    "catalog_status": "active",
+    "currency": "USD",
+    "billing_unit": "per_call",
+    "billing_strategy": "flat",
+    "unit_price_cents": 5,
+    "future_field": {"preserved": True},
+}
+
+
+@pytest.fixture(autouse=True)
+def reset_config(monkeypatch):
+    monkeypatch.delenv("RUNAPI_API_KEY", raising=False)
+    monkeypatch.setattr(config, "api_key", None)
+    yield
+
+
+def test_list_schedules_uses_live_endpoint_filters_and_revalidation_options():
+    options = RequestOptions(headers={"If-None-Match": '"schedule-v1"'})
+    http = FakeHttp(ApiResponse({"as_of": "2026-07-23T00:00:00.000000Z", "price_schedules": [SCHEDULE]}, {"ETag": '"schedule-v2"'}))
+
+    result = Pricing(http).list_schedules(
+        service="nano_banana", action="text_to_image", model="nano-banana", options=options
+    )
+
+    assert isinstance(result, PriceScheduleListResponse)
+    assert result.price_schedules[0].future_field.preserved is True
+    assert result.response_header("etag") == '"schedule-v2"'
+    assert http.calls == [
+        ("get", "/api/v1/price_schedules?service=nano_banana&action=text_to_image&model=nano-banana", None, options)
+    ]
+
+
+def test_create_quote_is_anonymous_by_default_and_returns_a_typed_quote():
+    http = FakeHttp(
+        {
+            "price_quote": {
+                "service": "nano_banana",
+                "action": "text_to_image",
+                "model": "nano-banana",
+                "pricing_status": "available",
+                "currency": "USD",
+                "reservation_amount_cents": 5,
+                "estimate_basis": "exact",
+                "as_of": "2026-07-23T00:00:00.000000Z",
+            }
+        }
+    )
+
+    result = Pricing(http).create_quote(
+        service="nano_banana", action="text_to_image", model="nano-banana", params={"prompt": "A glass observatory"}
+    )
+
+    assert isinstance(result, PriceQuoteResponse)
+    assert result.price_quote.reservation_amount_cents == 5
+    assert http.calls == [
+        (
+            "post",
+            "/api/v1/price_quotes",
+            {"service": "nano_banana", "action": "text_to_image", "model": "nano-banana", "params": {"prompt": "A glass observatory"}},
+            None,
+        )
+    ]
+
+
+def test_standalone_client_allows_anonymous_schedule_requests():
+    captured = {}
+
+    def handler(request):
+        captured["authorization"] = request.headers.get("authorization")
+        return httpx.Response(200, json={"as_of": "2026-07-23T00:00:00.000000Z", "price_schedules": []})
+
+    http = HttpClient(
+        ClientOptions(api_key=None, base_url="https://runapi.ai"), transport=httpx.MockTransport(handler)
+    )
+    result = PricingClient(http_client=http).list_schedules()
+
+    assert isinstance(result, PriceScheduleListResponse)
+    assert captured["authorization"] is None
+
+
+def test_schedule_revalidation_returns_none_for_not_modified():
+    http = HttpClient(
+        ClientOptions(api_key=None, base_url="https://runapi.ai"),
+        transport=httpx.MockTransport(lambda _request: httpx.Response(304, headers={"ETag": '"schedule-v1"'})),
+    )
+
+    result = PricingClient(http_client=http).list_schedules(options=RequestOptions(headers={"If-None-Match": '"schedule-v1"'}))
+
+    assert result is None
+
+
+def test_standalone_client_uses_configured_api_key_when_a_quote_needs_auth(monkeypatch):
+    monkeypatch.setattr(config, "api_key", "configured-key")
+    client = PricingClient()
+    try:
+        assert client._http._client.headers["authorization"] == "Bearer configured-key"
+    finally:
+        client._http.close()

runapi_core-0.2.4/src/runapi/core/version.py

@@ -1 +0,0 @@
-__version__ = "0.2.4"