synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev8__py3-none-any.whl

synth_ai/environments/tasks/filters.py

@@ -1,6 +1,8 @@
-from typing import Any, Collection, Optional
+from collections.abc import Collection
 from dataclasses import dataclass
-from synth_ai.environments.tasks.core import TaskInstanceMetadataFilter, TaskInstance
+from typing import Any
+
+from synth_ai.environments.tasks.core import TaskInstance, TaskInstanceMetadataFilter
 
 
 @dataclass
@@ -18,8 +20,8 @@ class ValueFilter(TaskInstanceMetadataFilter):
 @dataclass
 class RangeFilter(TaskInstanceMetadataFilter):
     key: str
-    min_val: Optional[float] = None
-    max_val: Optional[float] = None
+    min_val: float | None = None
+    max_val: float | None = None
 
     def __call__(self, instance: TaskInstance) -> bool:
         instance_value = getattr(instance.metadata, self.key, None)

synth_ai/environments/tasks/utils.py

@@ -2,17 +2,19 @@
 Utility functions and generic filters for taskset creation.
 """
 
-from typing import Any, Collection, Optional, List, Set
+from collections.abc import Collection
+from typing import Any
 from uuid import UUID, uuid4
+
 from synth_ai.environments.tasks.core import (
-    TaskInstanceMetadataFilter,
-    TaskInstanceSet,
     SplitInfo,
     TaskInstance,
+    TaskInstanceMetadataFilter,
+    TaskInstanceSet,
 )
 
 
-def parse_or_new_uuid(raw_id: Optional[str]) -> UUID:
+def parse_or_new_uuid(raw_id: str | None) -> UUID:
     """
     Parse a raw ID string into a UUID, or generate a new one if invalid or missing.
     """
@@ -43,8 +45,8 @@ class RangeFilter(TaskInstanceMetadataFilter):
     def __init__(
         self,
         key: str,
-        min_value: Optional[float] = None,
-        max_value: Optional[float] = None,
+        min_value: float | None = None,
+        max_value: float | None = None,
     ):
         self.key = key
         self.min_value = min_value
@@ -62,15 +64,15 @@ class RangeFilter(TaskInstanceMetadataFilter):
 def make_taskset(
     name: str,
     description: str,
-    instances: List[TaskInstance],
-    val_filter: Optional[TaskInstanceMetadataFilter] = None,
-    test_filter: Optional[TaskInstanceMetadataFilter] = None,
+    instances: list[TaskInstance],
+    val_filter: TaskInstanceMetadataFilter | None = None,
+    test_filter: TaskInstanceMetadataFilter | None = None,
 ) -> TaskInstanceSet:
     """
     Assemble a TaskInstanceSet by applying optional validation and test filters.
     """
-    val_ids: Set[Any] = set()
-    test_ids: Set[Any] = set()
+    val_ids: set[Any] = set()
+    test_ids: set[Any] = set()
     if val_filter:
         val_ids = {inst.id for inst in instances if val_filter(inst)}
     if test_filter:

synth_ai/evals/base.py

@@ -1,9 +1,8 @@
-from typing import List
 
 
 class Judgement:
     def __init__(
-        self, criteria: str, score: float, reasoning: str = "", evidence: List[str] = None
+        self, criteria: str, score: float, reasoning: str = "", evidence: list[str] = None
     ):
         self.criteria = criteria
         self.score = score
@@ -12,5 +11,5 @@ class Judgement:
 
 
 class BaseEval:
-    async def run(self, data: any) -> List[Judgement]:
+    async def run(self, data: any) -> list[Judgement]:
         pass

synth_ai/experimental/synth_oss.py

@@ -1,5 +1,5 @@
-
-"""
+# ruff: noqa
+'''
 Synth OSS Integration Module
 
 This module provides integration with Synth's open-source inference and training APIs
@@ -336,7 +336,7 @@ Implementation sketch (backend == "synth")
 The method is a *no-op* for the default (OpenAI) backend so existing code keeps
 working.
 
-"""
+'''
 
 
 """
@@ -443,4 +443,4 @@ async def warmup(
 So: **the existing endpoint does not yet support GPU selection; we need to add
 the small change above on the `learning_v2` side and then LM.warmup can request
 specific GPUs.**
-"""
+"""

synth_ai/http.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+
+@dataclass
+class HTTPError(Exception):
+    status: int
+    url: str
+    message: str
+    body_snippet: str | None = None
+    detail: Any | None = None
+
+    def __str__(self) -> str:  # pragma: no cover - trivial
+        base = f"HTTP {self.status} for {self.url}: {self.message}"
+        if self.body_snippet:
+            base += f" | body[0:200]={self.body_snippet[:200]}"
+        return base
+
+
+class AsyncHttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = aiohttp.ClientTimeout(total=timeout)
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def __aenter__(self) -> "AsyncHttpClient":
+        if self._session is None:
+            headers = {"authorization": f"Bearer {self._api_key}"}
+            self._session = aiohttp.ClientSession(headers=headers, timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # noqa: ANN001
+        if self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    def _abs(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        # If base_url already ends with /api and path starts with /api, remove duplicate
+        if self._base_url.endswith("/api") and path.startswith("/api"):
+            path = path[4:]  # Remove leading /api
+        return f"{self._base_url}/{path.lstrip('/')}"
+
+    async def get(self, path: str, *, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.get(url, params=params, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def post_json(self, path: str, *, json: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.post(url, json=json, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def post_multipart(self, path: str, *, data: Dict[str, Any], files: Dict[str, tuple[str, bytes, str | None]], headers: Optional[Dict[str, str]] = None) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        form = aiohttp.FormData()
+        for k, v in data.items():
+            form.add_field(k, str(v))
+        for field, (filename, content, content_type) in files.items():
+            form.add_field(field, content, filename=filename, content_type=content_type or "application/octet-stream")
+        async with self._session.post(url, data=form, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def delete(self, path: str, *, headers: Optional[Dict[str, str]] = None) -> Any:
+        url = self._abs(path)
+        assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
+        async with self._session.delete(url, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def _handle_response(self, resp: aiohttp.ClientResponse, url: str) -> Any:
+        text = await resp.text()
+        body_snippet = text[:200] if text else None
+        if 200 <= resp.status < 300:
+            ctype = resp.headers.get("content-type", "")
+            if "application/json" in ctype:
+                try:
+                    return await resp.json()
+                except Exception:
+                    # Fallback to text
+                    return text
+            return text
+        # error
+        detail: Any | None = None
+        try:
+            detail = await resp.json()
+        except Exception:
+            detail = None
+        raise HTTPError(status=resp.status, url=url, message="request_failed", body_snippet=body_snippet, detail=detail)
+
+
+async def sleep(seconds: float) -> None:
+    await asyncio.sleep(seconds)

synth_ai/inference/__init__.py

@@ -0,0 +1,7 @@
+from .client import InferenceClient
+
+__all__ = [
+    "InferenceClient",
+]
+
+

synth_ai/inference/client.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..http import AsyncHttpClient
+
+
+class InferenceClient:
+    def __init__(self, base_url: str, api_key: str, *, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+
+    async def create_chat_completion(self, *, model: str, messages: list[dict], **kwargs: Any) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"model": model, "messages": messages}
+        body.update(kwargs)
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            return await http.post_json("/v1/chat/completions", json=body)
+
+

synth_ai/jobs/client.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from synth_ai.http import AsyncHttpClient
+
+
+class FilesApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def upload(self, *, filename: str, content: bytes, purpose: str, content_type: Optional[str] = None, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+        data = {"purpose": purpose}
+        files = {"file": (filename, content, content_type)}
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._http.post_multipart("/api/files", data=data, files=files, headers=headers)
+
+    async def list(self, *, purpose: Optional[str] = None, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if purpose is not None:
+            params["purpose"] = purpose
+        if after is not None:
+            params["after"] = after
+        params["limit"] = limit
+        return await self._http.get("/api/files", params=params)
+
+    async def retrieve(self, file_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/files/{file_id}")
+
+    async def delete(self, file_id: str) -> Any:
+        return await self._http.delete(f"/api/files/{file_id}")
+
+    async def list_jobs(self, file_id: str, *, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/files/{file_id}/jobs", params=params)
+
+
+class SftJobsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def create(
+        self,
+        *,
+        training_file: str,
+        model: str,
+        validation_file: Optional[str] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        suffix: Optional[str] = None,
+        integrations: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "training_file": training_file,
+            "model": model,
+        }
+        if validation_file is not None:
+            payload["validation_file"] = validation_file
+        if hyperparameters is not None:
+            payload["hyperparameters"] = hyperparameters
+        if suffix is not None:
+            payload["suffix"] = suffix
+        if integrations is not None:
+            payload["integrations"] = integrations
+        if metadata is not None:
+            payload["metadata"] = metadata
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._http.post_json("/api/sft/jobs", json=payload, headers=headers)
+
+    async def list(
+        self,
+        *,
+        status: Optional[str] = None,
+        model: Optional[str] = None,
+        file_id: Optional[str] = None,
+        created_after: Optional[int] = None,
+        created_before: Optional[int] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if status is not None:
+            params["status"] = status
+        if model is not None:
+            params["model"] = model
+        if file_id is not None:
+            params["file_id"] = file_id
+        if created_after is not None:
+            params["created_after"] = created_after
+        if created_before is not None:
+            params["created_before"] = created_before
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/sft/jobs", params=params)
+
+    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/sft/jobs/{job_id}")
+
+    async def cancel(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.post_json(f"/api/sft/jobs/{job_id}/cancel", json={})
+
+    async def list_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> Dict[str, Any]:
+        params = {"since_seq": since_seq, "limit": limit}
+        return await self._http.get(f"/api/sft/jobs/{job_id}/events", params=params)
+
+    async def checkpoints(self, job_id: str, *, after: Optional[str] = None, limit: int = 10) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/sft/jobs/{job_id}/checkpoints", params=params)
+
+
+class RlJobsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def create(
+        self,
+        *,
+        model: str,
+        endpoint_base_url: str,
+        trainer_id: str,
+        trainer: Optional[Dict[str, Any]] = None,
+        job_config_id: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "model": model,
+            "endpoint_base_url": endpoint_base_url,
+            "trainer_id": trainer_id,
+        }
+        if trainer is not None:
+            payload["trainer"] = trainer
+        if job_config_id is not None:
+            payload["job_config_id"] = job_config_id
+        if config is not None:
+            payload["config"] = config
+        if metadata is not None:
+            payload["metadata"] = metadata
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._http.post_json("/api/rl/jobs", json=payload, headers=headers)
+
+    async def list(
+        self,
+        *,
+        status: Optional[str] = None,
+        model: Optional[str] = None,
+        created_after: Optional[int] = None,
+        created_before: Optional[int] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if status is not None:
+            params["status"] = status
+        if model is not None:
+            params["model"] = model
+        if created_after is not None:
+            params["created_after"] = created_after
+        if created_before is not None:
+            params["created_before"] = created_before
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/rl/jobs", params=params)
+
+    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/rl/jobs/{job_id}")
+
+    async def cancel(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.post_json(f"/api/rl/jobs/{job_id}/cancel", json={})
+
+    async def list_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> Dict[str, Any]:
+        params = {"since_seq": since_seq, "limit": limit}
+        return await self._http.get(f"/api/rl/jobs/{job_id}/events", params=params)
+
+    async def metrics(self, job_id: str, *, after_step: int = -1, limit: int = 200) -> Dict[str, Any]:
+        params = {"after_step": after_step, "limit": limit}
+        return await self._http.get(f"/api/rl/jobs/{job_id}/metrics", params=params)
+
+
+class ModelsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        *,
+        source: Optional[str] = None,
+        base_model: Optional[str] = None,
+        status: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if source is not None:
+            params["source"] = source
+        if base_model is not None:
+            params["base_model"] = base_model
+        if status is not None:
+            params["status"] = status
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/models", params=params)
+
+    async def retrieve(self, model_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/models/{model_id}")
+
+    async def delete(self, model_id: str) -> Any:
+        return await self._http.delete(f"/api/models/{model_id}")
+
+    async def list_jobs(self, model_id: str, *, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/models/{model_id}/jobs", params=params)
+
+
+class JobsClient:
+    """High-level client aggregating job APIs.
+
+    Usage:
+        async with JobsClient(base_url, api_key) as c:
+            await c.files.list()
+    """
+
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0, http: Optional[AsyncHttpClient] = None) -> None:
+        self._base_url = base_url
+        self._api_key = api_key
+        self._timeout = timeout
+        self._http = http or AsyncHttpClient(base_url, api_key, timeout=timeout)
+        self.files = FilesApi(self._http)
+        self.sft = SftJobsApi(self._http)
+        self.rl = RlJobsApi(self._http)
+        self.models = ModelsApi(self._http)
+
+    async def __aenter__(self) -> "JobsClient":
+        await self._http.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # noqa: ANN001
+        await self._http.__aexit__(exc_type, exc, tb)

synth_ai/learning/__init__.py

@@ -0,0 +1,24 @@
+from .client import LearningClient
+from .rl_client import RlClient
+from .ft_client import FtClient
+from .validators import validate_training_jsonl, validate_trainer_cfg_rl
+from synth_ai.task import validate_task_app_url, task_app_health
+from .health import backend_health, pricing_preflight, balance_autumn_normalized
+from .sse import stream_events as stream_job_events
+from .jobs import JobHandle, JobsApiResolver
+
+__all__ = [
+    "LearningClient",
+    "RlClient",
+    "FtClient",
+    "validate_training_jsonl",
+    "validate_trainer_cfg_rl",
+    "validate_task_app_url",
+    "backend_health",
+    "task_app_health",
+    "pricing_preflight",
+    "balance_autumn_normalized",
+    "stream_job_events",
+    "JobHandle",
+    "JobsApiResolver",
+]

synth_ai/learning/client.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional
+
+from ..http import AsyncHttpClient, HTTPError, sleep
+
+
+class LearningClient:
+    def __init__(self, base_url: str, api_key: str, *, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+
+    async def upload_training_file(self, path: str | Path, *, purpose: str = "fine-tune") -> str:
+        p = Path(path)
+        content = p.read_bytes()
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            data = {"purpose": purpose}
+            files = {"file": (p.name, content, _infer_content_type(p.name))}
+            js = await http.post_multipart("/api/learning/files", data=data, files=files)
+        if not isinstance(js, dict) or "id" not in js:
+            raise HTTPError(status=500, url="/api/learning/files", message="invalid_upload_response", body_snippet=str(js)[:200])
+        return str(js["id"])
+
+    async def create_job(
+        self,
+        *,
+        training_type: str,
+        model: str,
+        training_file_id: str,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        body = {
+            "training_type": training_type,
+            "model": model,
+            "training_file_id": training_file_id,
+            "hyperparameters": hyperparameters or {},
+            "metadata": metadata or {},
+        }
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            return await http.post_json("/api/learning/jobs", json=body)
+
+    async def start_job(self, job_id: str) -> Dict[str, Any]:
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            return await http.post_json(f"/api/learning/jobs/{job_id}/start", json={})
+
+    async def get_job(self, job_id: str) -> Dict[str, Any]:
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            return await http.get(f"/api/learning/jobs/{job_id}")
+
+    async def get_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> List[Dict[str, Any]]:
+        params = {"since_seq": since_seq, "limit": limit}
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get(f"/api/learning/jobs/{job_id}/events", params=params)
+        if isinstance(js, dict) and isinstance(js.get("events"), list):
+            return js["events"]
+        return []
+
+    async def get_metrics(self, job_id: str, *, name: str | None = None, after_step: int | None = None, limit: int = 500, run_id: str | None = None) -> List[Dict[str, Any]]:
+        params: Dict[str, Any] = {"limit": limit}
+        if name is not None:
+            params["name"] = name
+        if after_step is not None:
+            params["after_step"] = after_step
+        if run_id is not None:
+            params["run_id"] = run_id
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get(f"/api/learning/jobs/{job_id}/metrics", params=params)
+        if isinstance(js, dict) and isinstance(js.get("points"), list):
+            return js["points"]
+        return []
+
+    async def get_timeline(self, job_id: str, *, limit: int = 200) -> List[Dict[str, Any]]:
+        params = {"limit": limit}
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get(f"/api/learning/jobs/{job_id}/timeline", params=params)
+        if isinstance(js, dict) and isinstance(js.get("events"), list):
+            return js["events"]
+        return []
+
+    async def poll_until_terminal(
+        self,
+        job_id: str,
+        *,
+        interval_seconds: float = 2.0,
+        max_seconds: float | None = 3600,
+        on_event: Callable[[Dict[str, Any]], None] | None = None,
+    ) -> Dict[str, Any]:
+        last_seq = 0
+        elapsed = 0.0
+        while True:
+            # Events
+            events = await self.get_events(job_id, since_seq=last_seq, limit=200)
+            for e in events:
+                if isinstance(e, dict) and isinstance(e.get("seq"), int):
+                    last_seq = max(last_seq, int(e["seq"]))
+                if on_event:
+                    try:
+                        on_event(e)
+                    except Exception:
+                        pass
+
+            # Status
+            job = await self.get_job(job_id)
+            status = str(job.get("status") or "").lower()
+            if status in {"succeeded", "failed", "canceled", "cancelled"}:
+                return job
+
+            # Sleep and time budget
+            await sleep(interval_seconds)
+            elapsed += interval_seconds
+            if max_seconds is not None and elapsed >= max_seconds:
+                raise TimeoutError(f"Polling timed out after {elapsed} seconds for job {job_id}")
+
+    # --- Optional diagnostics ---
+    async def pricing_preflight(self, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int) -> Dict[str, Any]:
+        body = {
+            "job_type": job_type,
+            "gpu_type": gpu_type,
+            "estimated_seconds": float(estimated_seconds or 0.0),
+            "container_count": int(container_count or 1),
+        }
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.post_json("/api/v1/pricing/preflight", json=body)
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url="/api/v1/pricing/preflight", message="invalid_preflight_response", body_snippet=str(js)[:200])
+        return js
+
+    async def balance_autumn_normalized(self) -> Dict[str, Any]:
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get("/api/v1/balance/autumn-normalized")
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url="/api/v1/balance/autumn-normalized", message="invalid_balance_response", body_snippet=str(js)[:200])
+        return js
+
+
+def _infer_content_type(filename: str) -> str:
+    name = filename.lower()
+    if name.endswith(".jsonl"):
+        return "application/jsonl"
+    if name.endswith(".json"):
+        return "application/json"
+    if name.endswith(".txt"):
+        return "text/plain"
+    return "application/octet-stream"
+
+