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

synth_ai/__init__.py

@@ -23,7 +23,7 @@ from synth_ai.tracing_v1.abstractions import (
 from synth_ai.tracing_v1.decorators import trace_event_async, trace_event_sync
 from synth_ai.tracing_v1.upload import upload
 
-__version__ = "0.2.4.dev7"
+__version__ = "0.2.4.dev8"
 __all__ = [
     "LM",
     "tracing",

synth_ai/cli/balance.py

@@ -19,10 +19,10 @@ PROD_BACKEND_BASE = "https://agent-learning.onrender.com/api/v1"
 
 
 def _get_default_base_url() -> str:
-    # Prefer explicit backend variables that are NOT modal; else default to prod backend
+    # Prefer explicit backend variables; else default to prod backend
     for var in ("SYNTH_BACKEND_BASE_URL", "BACKEND_BASE_URL", "SYNTH_BASE_URL"):
         val = os.getenv(var)
-        if val and ("modal" not in val.lower() and "modal.run" not in val.lower()):
+        if val:
             return val
     return PROD_BACKEND_BASE
 
@@ -87,19 +87,7 @@ def register(cli):
 
         base = _ensure_api_v1_prefix(base_url)
 
-        # Hard guard: never hit Modal URLs for account balance
-        try:
-            parsed = urlparse(base)
-            host = (parsed.hostname or "").lower()
-        except Exception:
-            host = ""
-        if "modal" in host or "modal.run" in base.lower():
-            # Override to prod backend unconditionally
-            fallback = PROD_BACKEND_BASE
-            console.print(
-                f"[yellow]Detected remote Modal URL ({base}). Using backend instead:[/yellow] {fallback}"
-            )
-            base = fallback
+        # No special-casing for modal.run domains; honor the provided base URL
 
         try:
             resp: Response = requests.get(

synth_ai/config/base_url.py

@@ -49,3 +49,50 @@ def get_learning_v2_base_url(mode: Literal["dev", "prod"] = "prod") -> str:
         return _normalize_base(dev)
 
     raise Exception()
+
+
+def _resolve_override_mode() -> str:
+    """Return one of 'local', 'dev', 'prod' based on SYNTH_BACKEND_URL_OVERRIDE.
+
+    Defaults to 'prod' when unset or unrecognized.
+    """
+    ov = (os.getenv("SYNTH_BACKEND_URL_OVERRIDE", "") or "").strip().lower()
+    if ov in {"local", "dev", "prod"}:
+        return ov
+    return "prod"
+
+
+def get_backend_from_env() -> tuple[str, str]:
+    """Resolve (base_url, api_key) using a simple LOCAL/DEV/PROD override scheme.
+
+    Env vars consulted:
+    - SYNTH_BACKEND_URL_OVERRIDE = local|dev|prod (case-insensitive)
+    - LOCAL_BACKEND_URL, TESTING_LOCAL_SYNTH_API_KEY
+    - DEV_BACKEND_URL, DEV_SYNTH_API_KEY
+    - PROD_BACKEND_URL, TESTING_PROD_SYNTH_API_KEY (fallback to SYNTH_API_KEY)
+
+    Base URL is normalized to end with '/api'.
+    Defaults: prod base URL → https://agent-learning.onrender.com/api
+    """
+    mode = _resolve_override_mode()
+    if mode == "local":
+        base = os.getenv("LOCAL_BACKEND_URL", "http://localhost:8000")
+        key = os.getenv("TESTING_LOCAL_SYNTH_API_KEY", "")
+        return base.rstrip("/"), key
+    if mode == "dev":
+        base = os.getenv("DEV_BACKEND_URL", "") or "http://localhost:8000"
+        key = os.getenv("DEV_SYNTH_API_KEY", "")
+        return base.rstrip("/"), key
+    # prod
+    base = os.getenv("PROD_BACKEND_URL", f"{PROD_BASE_URL_DEFAULT}")
+    # Ensure we return the root (no trailing /api). If default includes /api, strip it.
+    base = base.rstrip("/")
+    if base.endswith("/api"):
+        base = base[: -len("/api")]
+    # Prefer explicit PROD key, then testing key, then generic fallback
+    key = (
+        os.getenv("PROD_SYNTH_API_KEY", "")
+        or os.getenv("TESTING_PROD_SYNTH_API_KEY", "")
+        or os.getenv("SYNTH_API_KEY", "")
+    )
+    return base, key

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"
+
+