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

synth_ai/learning/prompts/run_random_search_banking77.py

@@ -12,44 +12,46 @@ Run:
 from __future__ import annotations
 
 import asyncio
+import json
 import os
 import random
+import time
+from collections.abc import Sequence
 from dataclasses import dataclass, replace
+from pathlib import Path
 from types import SimpleNamespace
-from tqdm import tqdm
-from typing import Any, Dict, List, Sequence, Tuple
+from typing import Any
 
-from dotenv import load_dotenv
 from datasets import load_dataset
-
-from synth_ai.lm.core.main_v3 import LM, build_messages
-import json
-import time
-from pathlib import Path
+from dotenv import load_dotenv
 from synth_ai.learning.prompts.random_search import random_search_compile
+from synth_ai.lm.core.main_v3 import LM, build_messages
+from tqdm import tqdm
 
 
-def choose_label(pred: str, label_names: List[str]) -> str:
+def choose_label(pred: str, label_names: list[str]) -> str:
     norm = (pred or "").strip().lower()
     d = {ln.lower(): ln for ln in label_names}
     if norm in d:
         return d[norm]
+
     def score(cand: str) -> int:
         c = cand.lower()
         return sum(1 for w in c.split() if w in norm)
+
     return max(label_names, key=score)
 
 
-def accuracy(pred: str, gold: str, labels: List[str]) -> float:
+def accuracy(pred: str, gold: str, labels: list[str]) -> float:
     return 1.0 if choose_label(pred, labels) == gold else 0.0
 
 
 @dataclass
 class StudentProgram:
     lm: LM
-    label_names: List[str]
+    label_names: list[str]
     instruction: str
-    demos: List[Tuple[str, str]]
+    demos: list[tuple[str, str]]
 
     def reset_copy(self):
         return replace(self, instruction=self.instruction, demos=list(self.demos))
@@ -57,7 +59,7 @@ class StudentProgram:
     def deepcopy(self):
         return replace(self, instruction=str(self.instruction), demos=list(self.demos))
 
-    def with_demos(self, demos: List[Tuple[str, str]]):
+    def with_demos(self, demos: list[tuple[str, str]]):
         return replace(self, demos=list(demos))
 
     def run(self, x: str) -> str:
@@ -66,10 +68,12 @@ class StudentProgram:
         sys = self.instruction or "You are an intent classifier for Banking77."
         user = (f"Examples:\n{examples}\n\n" if examples else "") + f"Message: {x}\nLabel:"
         messages = build_messages(sys, user, images_bytes=None, model_name=self.lm.model)
+
         # Call LM synchronously via asyncio
         async def _call():
             resp = await self.lm.respond_async(messages=messages)
             return (resp.raw_response or "").strip()
+
         return asyncio.run(_call())
 
     async def _apredict(self, x: str):
@@ -91,13 +95,13 @@ def main():
 
     print("Loading Banking77 dataset (train/dev split of test for demo)...")
     ds = load_dataset("banking77")
-    label_names: List[str] = ds["test"].features["label"].names  # type: ignore
+    label_names: list[str] = ds["test"].features["label"].names  # type: ignore
 
     # Create small train/val from the test split for speed
     all_items = [(r["text"], label_names[int(r["label"])]) for r in ds["test"]]
     random.shuffle(all_items)
-    trainset: Sequence[Tuple[str, str]] = all_items[:40]
-    valset: Sequence[Tuple[str, str]] = all_items[40:60]  # 20 examples
+    trainset: Sequence[tuple[str, str]] = all_items[:40]
+    valset: Sequence[tuple[str, str]] = all_items[40:60]  # 20 examples
 
     student = StudentProgram(
         lm=lm,
@@ -110,17 +114,20 @@ def main():
         return accuracy(yhat, y, label_names)
 
     total_candidates = 3 + 3  # zero-shot, labeled few-shot, bootstrapped + 3 random seeds
-    print(f"Running Random Search optimizer ({total_candidates} candidates, parallel eval of 20 questions)...")
+    print(
+        f"Running Random Search optimizer ({total_candidates} candidates, parallel eval of 20 questions)..."
+    )
 
-    def eval_parallel(program: StudentProgram, dataset: Sequence[Tuple[str, str]], metric_fn):
+    def eval_parallel(program: StudentProgram, dataset: Sequence[tuple[str, str]], metric_fn):
         async def _run():
             xs = [x for x, _ in dataset]
             ys = [y for _, y in dataset]
-            preds: List[Optional[str]] = [None] * len(xs)
+            preds: list[Optional[str]] = [None] * len(xs)
             sem = asyncio.Semaphore(int(os.getenv("CONCURRENCY", "5")))
 
             async def worker(i: int, x: str, y: str):
                 import time
+
                 t_start = time.monotonic()
                 try:
                     async with sem:
@@ -138,16 +145,18 @@ def main():
                     t_end = time.monotonic()
                     return i, y, "", t_start, t_end, {}
 
-            tasks = [asyncio.create_task(worker(i, x, y)) for i, (x, y) in enumerate(zip(xs, ys))]
+            tasks = [asyncio.create_task(worker(i, x, y)) for i, (x, y) in enumerate(zip(xs, ys, strict=False))]
             correct_sum = 0.0
             processed = 0
-            import time, statistics
-            durations: List[float] = []
+            import statistics
+            import time
+
+            durations: list[float] = []
             in_tok_sum = 0
             out_tok_sum = 0
             in_tok_count = 0
             out_tok_count = 0
-            details: List[Dict[str, Any]] = []
+            details: list[dict[str, Any]] = []
             t_batch_start = time.monotonic()
             deadline = float(os.getenv("BATCH_DEADLINE_S", "20"))
             with tqdm(total=len(tasks), desc="Rollouts", leave=False) as pbar:
@@ -172,7 +181,10 @@ def main():
                         break
                     # Wait for at least one completion within remaining time (polling granularity <= 1s)
                     timeout = min(1.0, remaining)
-                    done, pending = await asyncio.wait(pending, timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
+                    done, pending = await asyncio.wait(
+                        pending, timeout=timeout, return_when=asyncio.FIRST_COMPLETED
+                    )
+                    import contextlib
                     for task in done:
                         try:
                             i, y_true, pred, t_start, t_end, usage = task.result()
@@ -182,11 +194,9 @@ def main():
                         durations.append(max(0.0, t_end - t_start))
                         preds[i] = pred
                         processed += 1
-                        try:
+                        with contextlib.suppress(Exception):
                             correct_sum += float(metric_fn(pred, y_true))
-                        except Exception:
-                            pass
-                        try:
+                        with contextlib.suppress(Exception):
                             pt = usage.get("prompt_tokens") or usage.get("input_tokens")
                             ct = usage.get("completion_tokens") or usage.get("output_tokens")
                             if isinstance(pt, (int, float)):
@@ -195,30 +205,34 @@ def main():
                             if isinstance(ct, (int, float)):
                                 out_tok_sum += int(ct)
                                 out_tok_count += 1
-                        except Exception:
-                            pass
-                        details.append({
-                            "index": i,
-                            "seconds": max(0.0, t_end - t_start),
-                            "score": float(metric_fn(pred, y_true)),
-                            "usage": {
-                                "prompt_tokens": usage.get("prompt_tokens") or usage.get("input_tokens"),
-                                "completion_tokens": usage.get("completion_tokens") or usage.get("output_tokens"),
-                            },
-                        })
+                        details.append(
+                            {
+                                "index": i,
+                                "seconds": max(0.0, t_end - t_start),
+                                "score": float(metric_fn(pred, y_true)),
+                                "usage": {
+                                    "prompt_tokens": usage.get("prompt_tokens")
+                                    or usage.get("input_tokens"),
+                                    "completion_tokens": usage.get("completion_tokens")
+                                    or usage.get("output_tokens"),
+                                },
+                            }
+                        )
                         pbar.update(1)
                         med = statistics.median(durations) if durations else 0.0
                         mx = max(durations) if durations else 0.0
                         avg_in = (in_tok_sum / in_tok_count) if in_tok_count else 0.0
                         avg_out = (out_tok_sum / out_tok_count) if out_tok_count else 0.0
-                        pbar.set_postfix({
-                            "acc": f"{(correct_sum/processed):.2f}",
-                            "done": f"{processed}/{len(tasks)}",
-                            "med_s": f"{med:.1f}",
-                            "max_s": f"{mx:.1f}",
-                            "tin": f"{avg_in:.1f}",
-                            "tout": f"{avg_out:.1f}",
-                        })
+                        pbar.set_postfix(
+                            {
+                                "acc": f"{(correct_sum / processed):.2f}",
+                                "done": f"{processed}/{len(tasks)}",
+                                "med_s": f"{med:.1f}",
+                                "max_s": f"{mx:.1f}",
+                                "tin": f"{avg_in:.1f}",
+                                "tout": f"{avg_out:.1f}",
+                            }
+                        )
             # Compute score only from completed/successful rollouts (drop timeouts/cancelled)
             subs = [float(d.get("score", 0.0)) for d in details]
             result = SimpleNamespace(score=(sum(subs) / max(1, len(subs))), subscores=subs)
@@ -226,28 +240,33 @@ def main():
             result.mean_in = (in_tok_sum / in_tok_count) if in_tok_count else 0.0
             result.mean_out = (out_tok_sum / out_tok_count) if out_tok_count else 0.0
             return result
+
         return asyncio.run(_run())
+
     pbar = tqdm(total=total_candidates, desc="Candidates")
-    candidate_eval_details: Dict[int, Any] = {}
+    candidate_eval_details: dict[int, Any] = {}
+
     def on_cand(idx: int, score: float, res, intervention):
         pbar.update(1)
         pbar.set_postfix({"score": f"{score:.2f}"})
         # store per-instance details (for apples-to-apples)
-        try:
+        import contextlib
+        with contextlib.suppress(Exception):
             candidate_eval_details[idx] = {
                 "score": score,
                 "mean_in": getattr(res, "mean_in", None),
                 "mean_out": getattr(res, "mean_out", None),
                 "instances": getattr(res, "details", None),
             }
-        except Exception:
-            pass
         # visible summary line per candidate
-        kind = intervention.get("kind", "candidate") if isinstance(intervention, dict) else "candidate"
+        kind = (
+            intervention.get("kind", "candidate") if isinstance(intervention, dict) else "candidate"
+        )
         label = intervention.get("label") if isinstance(intervention, dict) else None
         seed = intervention.get("seed") if isinstance(intervention, dict) else None
         processed = len(getattr(res, "details", []) or [])
         from tqdm import tqdm as _tqdm
+
         _tqdm.write(
             f"Candidate {idx}/{total_candidates} [{kind}{'' if label is None else f', label={label}'}{'' if seed is None else f', seed={seed}'}]: "
             f"score={score:.2f} | mean tin/tout={getattr(res, 'mean_in', 0):.1f}/{getattr(res, 'mean_out', 0):.1f} | N={processed}"

synth_ai/learning/rl_client.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Callable
+import os
+import time
+
+from ..http import AsyncHttpClient, HTTPError, sleep
+
+
+def _api_base(b: str) -> str:
+    b = (b or "").rstrip("/")
+    return b if b.endswith("/api") else f"{b}/api"
+
+
+class RlClient:
+    """Lightweight RL client for provider-agnostic job control.
+
+    Notes:
+    - Uses learning/* for status/events/metrics and rl/* for creation/start.
+    - Trainer endpoints are resolved server-side via trainer_id.
+    """
+
+    def __init__(self, base_url: str, api_key: str, *, timeout: float = 600.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+
+    async def resolve_trainer_start_url(self, trainer_id: str) -> str:
+        """GET /api/rl/services/{id} → { training_start_url }"""
+        path = f"/api/rl/services/{trainer_id}"
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            js = await http.get(path)
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url=path, message="invalid_service_response", body_snippet=str(js)[:200])
+        start_url = js.get("training_start_url")
+        if not isinstance(start_url, str) or not start_url:
+            raise HTTPError(status=500, url=path, message="missing_training_start_url", body_snippet=str(js)[:200])
+        return start_url
+
+    async def create_job(
+        self,
+        *,
+        model: str,
+        task_app_url: str,
+        trainer: Dict[str, Any],
+        trainer_id: Optional[str] = None,
+        job_config_id: Optional[str] = None,
+        inline_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        body = {
+            "job_type": "rl",
+            "data": {
+                "model": model,
+                "endpoint_base_url": task_app_url,
+                **({"job_config_id": job_config_id} if job_config_id else {}),
+                **({"config": inline_config} if inline_config else {}),
+                "trainer": {
+                    "batch_size": int(trainer.get("batch_size", 1)),
+                    "group_size": max(2, int(trainer.get("group_size", 2))),
+                },
+            },
+        }
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.post_json(f"{_api_base(self._base_url)}/rl/jobs", json=body)
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url="/api/rl/jobs", message="invalid_create_response", body_snippet=str(js)[:200])
+        return js
+
+    async def start_job_if_supported(self, job_id: str) -> Optional[Dict[str, Any]]:
+        path = f"{_api_base(self._base_url)}/rl/jobs/{job_id}/start"
+        try:
+            async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+                return await http.post_json(path, json={})
+        except HTTPError as he:  # noqa: PERF203
+            if he.status == 404:
+                return None
+            raise
+
+    async def get_job(self, job_id: str) -> Dict[str, Any]:
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            return await http.get(f"{_api_base(self._base_url)}/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=30.0) as http:
+            try:
+                js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events", params=params)
+            except HTTPError as he:
+                try:
+                    print(
+                        f"[poll] events HTTPError status={he.status} url={he.url} since_seq={since_seq} body={(he.body_snippet or '')[:200]}"
+                    )
+                except Exception:
+                    pass
+                raise
+        if isinstance(js, dict):
+            evs = js.get("events") or js.get("data")
+            if isinstance(evs, list):
+                return evs
+        return []
+
+    async def get_metrics(self, job_id: str, *, after_step: int = -1, limit: int = 200) -> List[Dict[str, Any]]:
+        params = {"after_step": after_step, "limit": limit}
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/metrics", params=params)
+        if isinstance(js, dict) and isinstance(js.get("points"), list):
+            return js["points"]
+        return []
+
+    async def poll_until_terminal(
+        self,
+        job_id: str,
+        *,
+        interval_seconds: float = 2.0,
+        max_seconds: float | None = None,
+        empty_polls_threshold: int = 5,
+        startup_deadline_s: int = 45,
+        on_event: Optional[Callable[[Dict[str, Any]], None]] = None,
+        on_metric: Optional[Callable[[Dict[str, Any]], None]] = None,
+    ) -> Dict[str, Any]:
+        last_seq_by_stream: Dict[str, int] = {}
+        events_job_id: Optional[str] = None
+        last_status: Optional[str] = None
+        last_step_by_name: Dict[str, int] = {}
+        empty_polls = 0
+        saw_any_event = False
+        start_t = time.time()
+        terminal = {"succeeded", "failed", "cancelled", "canceled", "error", "completed"}
+
+        while True:
+            status_data: Optional[Dict[str, Any]] = None
+            try:
+                status_data = await self.get_job(job_id)
+            except Exception:
+                status_data = None
+            if status_data is None:
+                try:
+                    print(f"[poll] get_job returned None base={self._base_url} job_id={job_id}")
+                except Exception:
+                    pass
+            status = str((status_data or {}).get("status") or "").lower()
+            if status_data:
+                linked = status_data.get("linked_job_id")
+                if isinstance(linked, str) and linked and linked != events_job_id:
+                    events_job_id = linked
+                    try:
+                        print(f"[poll] discovered linked_job_id stream={events_job_id}")
+                    except Exception:
+                        pass
+            if status and status != last_status:
+                last_status = status
+                # Status transitions only to avoid log spam
+                if on_event:
+                    try:
+                        on_event({"type": "rl.status", "message": status})
+                    except Exception:
+                        pass
+
+            # Events
+            stream_ids = [job_id]
+            if events_job_id and events_job_id not in stream_ids:
+                stream_ids.append(events_job_id)
+            try:
+                print(f"[poll] streams={stream_ids} intervals={interval_seconds}s since_map={last_seq_by_stream} empty_polls={empty_polls}")
+            except Exception:
+                pass
+            total_events_this_cycle = 0
+            terminal_event_seen = False
+            terminal_event_status: Optional[str] = None
+            for ev_id in stream_ids:
+                since = last_seq_by_stream.get(ev_id, 0)
+                try:
+                    events = await self.get_events(ev_id, since_seq=since, limit=200)
+                except HTTPError as he:
+                    try:
+                        print(f"[poll] get_events error status={he.status} url={he.url} since={since} body={(he.body_snippet or '')[:200]}")
+                    except Exception:
+                        pass
+                    events = []
+                except Exception as e:
+                    try:
+                        print(f"[poll] get_events unexpected error ev_id={ev_id} since={since} err={type(e).__name__}: {e}")
+                    except Exception:
+                        pass
+                    events = []
+                total_events_this_cycle += len(events)
+                if events:
+                    saw_any_event = True
+                for e in events:
+                    seq_val = int(e.get("seq") or 0)
+                    if seq_val <= last_seq_by_stream.get(ev_id, 0):
+                        continue
+                    last_seq_by_stream[ev_id] = seq_val
+                    if on_event:
+                        try:
+                            on_event(e)
+                        except Exception:
+                            pass
+                    et = str(e.get("type") or e.get("event_type") or "").lower()
+                    if et in ("rl.job.completed", "workflow.completed", "rl.train.completed"):
+                        terminal_event_seen = True
+                        terminal_event_status = "succeeded"
+                    elif et in ("rl.job.failed", "workflow.failed"):
+                        terminal_event_seen = True
+                        terminal_event_status = "failed"
+
+            # Metrics
+            try:
+                after = max(last_step_by_name.values()) if last_step_by_name else -1
+                points = await self.get_metrics(job_id, after_step=after, limit=200)
+                for p in points:
+                    name = str(p.get("name") or "")
+                    step = int(p.get("step") or -1)
+                    if step <= last_step_by_name.get(name, -1):
+                        continue
+                    last_step_by_name[name] = step
+                    if on_metric:
+                        try:
+                            on_metric(p)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+            if terminal_event_seen:
+                return {"status": terminal_event_status or status or "completed", "job_id": job_id}
+            if status and status in terminal:
+                return {"status": status, "job_id": job_id}
+
+            if total_events_this_cycle == 0:
+                empty_polls += 1
+            else:
+                empty_polls = 0
+            if empty_polls >= max(1, int(empty_polls_threshold)):
+                try:
+                    print(
+                        f"[poll] threshold hit: empty_polls={empty_polls} >= {empty_polls_threshold} streams={stream_ids} last_seq_map={last_seq_by_stream}"
+                    )
+                except Exception:
+                    pass
+                raise AssertionError(f"No new events detected for {empty_polls_threshold} consecutive polls. Check event ingestion.")
+
+            if not saw_any_event and (time.time() - start_t) > int(startup_deadline_s):
+                try:
+                    print(
+                        f"[poll] startup window exceeded: {startup_deadline_s}s base={self._base_url} job={job_id} streams={stream_ids} last_seq_map={last_seq_by_stream}"
+                    )
+                except Exception:
+                    pass
+                raise AssertionError(f"No events observed within startup window ({startup_deadline_s}s). Investigate event streaming.")
+
+            await sleep(interval_seconds)
+            if max_seconds is not None and (time.time() - start_t) >= max_seconds:
+                raise TimeoutError(f"Polling timed out after {max_seconds}s for job {job_id}")
+
+

synth_ai/learning/sse.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Callable, Optional
+
+import aiohttp
+
+
+def _api_base(b: str) -> str:
+    b = (b or "").rstrip("/")
+    return b if b.endswith("/api") else f"{b}/api"
+
+
+async def stream_events(
+    base_url: str,
+    api_key: str,
+    job_id: str,
+    *,
+    seconds: int = 60,
+    on_event: Optional[Callable[[dict], None]] = None,
+) -> None:
+    if seconds <= 0:
+        return
+    headers = {"Accept": "text/event-stream", "Authorization": f"Bearer {api_key}"}
+    candidates = [
+        f"{_api_base(base_url)}/rl/jobs/{job_id}/events?since_seq=0",
+        f"{_api_base(base_url)}/learning/jobs/{job_id}/events?since_seq=0",
+    ]
+    for url in candidates:
+        try:
+            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=None)) as session:
+                async with session.get(url, headers=headers) as resp:
+                    if resp.status != 200:
+                        continue
+                    start_t = time.time()
+                    async for raw in resp.content:
+                        line = raw.decode(errors="ignore").strip()
+                        if not line or line.startswith(":"):
+                            continue
+                        if not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        try:
+                            obj = json.loads(data)
+                        except Exception:
+                            continue
+                        if on_event:
+                            try:
+                                on_event(obj)
+                            except Exception:
+                                pass
+                        if (time.time() - start_t) >= seconds:
+                            return
+        except Exception:
+            continue
+
+

synth_ai/learning/validators.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import Path
+import json
+from typing import Any, Dict
+from urllib.parse import urlparse
+
+
+def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(str(p))
+    lines = p.read_text().splitlines()
+    if not lines:
+        raise ValueError("empty JSONL")
+    for i, line in enumerate(lines[: max(1, sample_lines) ], start=1):
+        if not line.strip():
+            continue
+        try:
+            obj = json.loads(line)
+        except Exception as e:
+            raise ValueError(f"invalid json on line {i}: {e}") from e
+        msgs = obj.get("messages")
+        if not isinstance(msgs, list) or len(msgs) < 2:
+            raise ValueError(f"line {i}: missing messages[] with at least 2 turns")
+        roles = [m.get("role") for m in msgs if isinstance(m, dict)]
+        if not roles or not isinstance(roles[0], str):
+            raise ValueError(f"line {i}: missing first role")
+        for m in msgs:
+            if not isinstance(m, dict):
+                raise ValueError(f"line {i}: non-dict message")
+            if not isinstance(m.get("role"), str) or not isinstance(m.get("content"), str) or not m["content"].strip():
+                raise ValueError(f"line {i}: invalid role/content")
+
+
+def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
+    from synth_ai.task.validators import validate_task_app_url as _vt
+
+    _vt(url, name=name)
+
+
+def validate_trainer_cfg_rl(trainer: Dict[str, Any]) -> None:
+    bs = int(trainer.get("batch_size", 1))
+    gs = int(trainer.get("group_size", 2))
+    if bs < 1:
+        raise ValueError("trainer.batch_size must be >= 1")
+    if gs < 2:
+        raise ValueError("trainer.group_size must be >= 2")

synth_ai/lm/__init__.py

@@ -4,24 +4,24 @@ Synth AI Language Model Interface.
 Provides a unified interface for multiple LLM providers including OpenAI and Synth.
 """
 
-from .config import SynthConfig, OpenAIConfig
-from .warmup import warmup_synth_model, get_warmup_status
+from .config import OpenAIConfig, SynthConfig
+from .core.main_v3 import LM
 from .unified_interface import (
-    UnifiedLMProvider,
     OpenAIProvider,
     SynthProvider,
     UnifiedLMClient,
+    UnifiedLMProvider,
     create_provider,
 )
 from .vendors.synth_client import (
     AsyncSynthClient,
     SyncSynthClient,
     create_async_client,
-    create_sync_client,
     create_chat_completion_async,
     create_chat_completion_sync,
+    create_sync_client,
 )
-from .core.main_v3 import LM
+from .warmup import get_warmup_status, warmup_synth_model
 
 __all__ = [
     # Configuration