synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.10__py3-none-any.whl

synth_ai/jobs/client.py

@@ -1,22 +1,36 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Optional
+from typing import Any
 
+from synth_ai.api.models.supported import normalize_model_identifier
 from synth_ai.http import AsyncHttpClient
+from synth_ai.learning.sft.config import prepare_sft_job_payload
 
 
 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]:
+    async def upload(
+        self,
+        *,
+        filename: str,
+        content: bytes,
+        purpose: str,
+        content_type: str | None = None,
+        idempotency_key: str | None = 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)
+        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] = {}
+    async def list(
+        self, *, purpose: str | None = None, after: str | None = None, limit: int = 20
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {}
         if purpose is not None:
             params["purpose"] = purpose
         if after is not None:
@@ -24,14 +38,16 @@ class FilesApi:
         params["limit"] = limit
         return await self._http.get("/api/files", params=params)
 
-    async def retrieve(self, file_id: str) -> Dict[str, Any]:
+    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}
+    async def list_jobs(
+        self, file_id: str, *, after: str | None = 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)
@@ -46,42 +62,40 @@ class SftJobsApi:
         *,
         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
+        validation_file: str | None = None,
+        hyperparameters: dict[str, Any] | None = None,
+        suffix: str | None = None,
+        integrations: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        payload = prepare_sft_job_payload(
+            model=model,
+            training_file=training_file,
+            hyperparameters=hyperparameters,
+            metadata=metadata,
+            training_type=None,
+            validation_file=validation_file,
+            suffix=suffix,
+            integrations=integrations,
+            training_file_field="training_file",
+            require_training_file=True,
+        )
         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,
+        status: str | None = None,
+        model: str | None = None,
+        file_id: str | None = None,
+        created_after: int | None = None,
+        created_before: int | None = None,
+        after: str | None = None,
         limit: int = 20,
-    ) -> Dict[str, Any]:
-        params: Dict[str, Any] = {"limit": limit}
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"limit": limit}
         if status is not None:
             params["status"] = status
         if model is not None:
@@ -96,18 +110,22 @@ class SftJobsApi:
             params["after"] = after
         return await self._http.get("/api/sft/jobs", params=params)
 
-    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+    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]:
+    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]:
+    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}
+    async def checkpoints(
+        self, job_id: str, *, after: str | None = 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)
@@ -123,14 +141,14 @@ class RlJobsApi:
         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,
+        trainer: dict[str, Any] | None = None,
+        job_config_id: str | None = None,
+        config: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+        idempotency_key: str | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {
+            "model": normalize_model_identifier(model),
             "endpoint_base_url": endpoint_base_url,
             "trainer_id": trainer_id,
         }
@@ -148,14 +166,14 @@ class RlJobsApi:
     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,
+        status: str | None = None,
+        model: str | None = None,
+        created_after: int | None = None,
+        created_before: int | None = None,
+        after: str | None = None,
         limit: int = 20,
-    ) -> Dict[str, Any]:
-        params: Dict[str, Any] = {"limit": limit}
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"limit": limit}
         if status is not None:
             params["status"] = status
         if model is not None:
@@ -168,17 +186,21 @@ class RlJobsApi:
             params["after"] = after
         return await self._http.get("/api/rl/jobs", params=params)
 
-    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+    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]:
+    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]:
+    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]:
+    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)
 
@@ -190,13 +212,13 @@ class ModelsApi:
     async def list(
         self,
         *,
-        source: Optional[str] = None,
-        base_model: Optional[str] = None,
-        status: Optional[str] = None,
-        after: Optional[str] = None,
+        source: str | None = None,
+        base_model: str | None = None,
+        status: str | None = None,
+        after: str | None = None,
         limit: int = 20,
-    ) -> Dict[str, Any]:
-        params: Dict[str, Any] = {"limit": limit}
+    ) -> dict[str, Any]:
+        params: dict[str, Any] = {"limit": limit}
         if source is not None:
             params["source"] = source
         if base_model is not None:
@@ -207,28 +229,31 @@ class ModelsApi:
             params["after"] = after
         return await self._http.get("/api/models", params=params)
 
-    async def retrieve(self, model_id: str) -> Dict[str, Any]:
+    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}
+    async def list_jobs(
+        self, model_id: str, *, after: str | None = 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.
+    """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:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+        http: AsyncHttpClient | None = None,
+    ) -> None:
         self._base_url = base_url
         self._api_key = api_key
         self._timeout = timeout
@@ -238,7 +263,7 @@ class JobsClient:
         self.rl = RlJobsApi(self._http)
         self.models = ModelsApi(self._http)
 
-    async def __aenter__(self) -> "JobsClient":
+    async def __aenter__(self) -> JobsClient:
         await self._http.__aenter__()
         return self
 

synth_ai/learning/__init__.py

@@ -1,16 +1,51 @@
+from synth_ai.task import task_app_health, validate_task_app_url
+
 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 .health import backend_health, balance_autumn_normalized, pricing_preflight
 from .jobs import JobHandle, JobsApiResolver
+from .rl import (
+    MAX_ENVIRONMENT_API_KEY_BYTES,
+    RlClient,
+    RLJobConfig,
+    RolloutEnvSpec,
+    RolloutMetrics,
+    RolloutPolicySpec,
+    RolloutRecordConfig,
+    RolloutRequest,
+    RolloutResponse,
+    RolloutSafetyConfig,
+    RolloutStep,
+    RolloutTrajectory,
+    encrypt_for_backend,
+    mint_environment_api_key,
+    setup_environment_api_key,
+)
+from .sft import FtClient
+from .sft.config import SFTJobConfig, prepare_sft_job_payload
+from .sse import stream_events as stream_job_events
+from .validators import validate_trainer_cfg_rl, validate_training_jsonl
 
 __all__ = [
     "LearningClient",
     "RlClient",
+    "RLJobConfig",
     "FtClient",
+    "SFTJobConfig",
+    "prepare_sft_job_payload",
+    "RolloutEnvSpec",
+    "RolloutPolicySpec",
+    "RolloutRecordConfig",
+    "RolloutSafetyConfig",
+    "RolloutRequest",
+    "RolloutStep",
+    "RolloutTrajectory",
+    "RolloutMetrics",
+    "RolloutResponse",
+    "mint_environment_api_key",
+    "encrypt_for_backend",
+    "setup_environment_api_key",
+    "MAX_ENVIRONMENT_API_KEY_BYTES",
+    # convenience re-export for typing
     "validate_training_jsonl",
     "validate_trainer_cfg_rl",
     "validate_task_app_url",

synth_ai/learning/algorithms.py

@@ -0,0 +1,14 @@
+# class LearningModality(str, enum.Enum):
+#     """Modality of learning."""
+
+#     online_on_policy = "online_on_policy"
+#     online_off_policy = "online_off_policy"
+#     offline = "offline"
+
+
+# class LearningAlgorithm(str, enum.Enum):
+#     """Algorithm of learning."""
+
+#     gspo = "gspo"
+#     reinforce = "reinforce"
+#     sft = "sft"

synth_ai/learning/client.py

@@ -1,7 +1,15 @@
 from __future__ import annotations
 
+from collections.abc import Callable
+from contextlib import suppress
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, TypedDict
+
+from synth_ai.api.models.supported import (
+    UnsupportedModelError,
+    normalize_model_identifier,
+)
+from synth_ai.learning.sft.config import prepare_sft_job_payload
 
 from ..http import AsyncHttpClient, HTTPError, sleep
 
@@ -20,7 +28,12 @@ class LearningClient:
             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])
+            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(
@@ -29,28 +42,56 @@ class LearningClient:
         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 {},
-        }
+        hyperparameters: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+        validation_file: str | None = None,
+    ) -> dict[str, Any]:
+        lower_type = (training_type or "").strip().lower()
+        require_base = (
+            lower_type.startswith("sft")
+            or lower_type.startswith("fft")
+            or lower_type.startswith("qft")
+        )
+        try:
+            normalized_model = normalize_model_identifier(
+                model, allow_finetuned_prefixes=not require_base
+            )
+        except UnsupportedModelError as exc:
+            raise ValueError(str(exc)) from exc
+
+        if lower_type.startswith("sft") or lower_type in {"fft", "qft"}:
+            body = prepare_sft_job_payload(
+                model=model,
+                training_file=training_file_id,
+                hyperparameters=hyperparameters,
+                metadata=metadata,
+                training_type=training_type or "sft_offline",
+                validation_file=validation_file,
+                training_file_field="training_file_id",
+                require_training_file=True,
+            )
+        else:
+            body = {
+                "training_type": training_type,
+                "model": normalized_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 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 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]]:
+    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)
@@ -58,8 +99,16 @@ class LearningClient:
             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}
+    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:
@@ -72,7 +121,7 @@ class LearningClient:
             return js["points"]
         return []
 
-    async def get_timeline(self, job_id: str, *, limit: int = 200) -> List[Dict[str, Any]]:
+    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)
@@ -86,8 +135,8 @@ class LearningClient:
         *,
         interval_seconds: float = 2.0,
         max_seconds: float | None = 3600,
-        on_event: Callable[[Dict[str, Any]], None] | None = None,
-    ) -> Dict[str, Any]:
+        on_event: Callable[[dict[str, Any]], None] | None = None,
+    ) -> dict[str, Any]:
         last_seq = 0
         elapsed = 0.0
         while True:
@@ -97,10 +146,8 @@ class LearningClient:
                 if isinstance(e, dict) and isinstance(e.get("seq"), int):
                     last_seq = max(last_seq, int(e["seq"]))
                 if on_event:
-                    try:
+                    with suppress(Exception):
                         on_event(e)
-                    except Exception:
-                        pass
 
             # Status
             job = await self.get_job(job_id)
@@ -115,7 +162,9 @@ class LearningClient:
                 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]:
+    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,
@@ -125,17 +174,62 @@ class LearningClient:
         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])
+            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 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])
+            raise HTTPError(
+                status=500,
+                url="/api/v1/balance/autumn-normalized",
+                message="invalid_balance_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
 
+class FineTunedModelInfo(TypedDict, total=False):
+    id: str
+    base_model: str | None
+    created_at: int | None
+    job_id: str | None
+    status: str | None
+
+
+class LearningClient(LearningClient):  # type: ignore[misc]
+    async def list_fine_tuned_models(self) -> list[FineTunedModelInfo]:
+        """Return completed fine‑tuned models for the caller's organization.
+
+        Calls backend route `/api/learning/models` and returns a compact list.
+        """
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.get("/api/learning/models")
+        if isinstance(js, dict) and isinstance(js.get("data"), list):
+            out: list[FineTunedModelInfo] = []
+            for item in js["data"]:
+                if not isinstance(item, dict):
+                    continue
+                rec: FineTunedModelInfo = {
+                    "id": str(item.get("id")),
+                    "base_model": item.get("base_model"),
+                    "created_at": item.get("created_at"),
+                    "job_id": item.get("job_id"),
+                    "status": item.get("status"),
+                }
+                if rec.get("id"):
+                    out.append(rec)
+            return out
+        # Fallback: empty list on unexpected shape
+        return []
+
+
 def _infer_content_type(filename: str) -> str:
     name = filename.lower()
     if name.endswith(".jsonl"):
@@ -145,5 +239,3 @@ def _infer_content_type(filename: str) -> str:
     if name.endswith(".txt"):
         return "text/plain"
     return "application/octet-stream"
-
-

synth_ai/learning/config.py

@@ -1,43 +1,5 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class FTJobConfig:
-    model: str
-    training_file_id: str
-    n_epochs: int = 1
-    batch_size: int = 1
-    upload_to_wasabi: bool = True
-
-    def hyperparameters(self) -> Dict[str, Any]:
-        if self.n_epochs < 1:
-            raise ValueError("n_epochs must be >= 1")
-        if self.batch_size < 1:
-            raise ValueError("batch_size must be >= 1")
-        return {"n_epochs": int(self.n_epochs), "batch_size": int(self.batch_size)}
-
-    def metadata(self) -> Dict[str, Any]:  # type: ignore[override]
-        return {"upload_to_wasabi": bool(self.upload_to_wasabi)}
-
-
-@dataclass
-class RLJobConfig:
-    model: str
-    task_app_url: str
-    trainer_id: str
-    batch_size: int = 1
-    group_size: int = 2
-    job_config_id: Optional[str] = None
-    inline_config: Optional[Dict[str, Any]] = None
-
-    def trainer_dict(self) -> Dict[str, Any]:
-        if self.batch_size < 1:
-            raise ValueError("batch_size must be >= 1")
-        if self.group_size < 2:
-            raise ValueError("group_size must be >= 2")
-        return {"batch_size": int(self.batch_size), "group_size": int(self.group_size)}
-
+from .rl.config import RLJobConfig
 
+__all__ = ["RLJobConfig"]

synth_ai/learning/constants.py

@@ -25,5 +25,3 @@ TERMINAL_EVENT_FAILURE = {
     "rl.job.failed",
     "workflow.failed",
 }
-
-