freesolo 0.2.43__tar.gz → 0.2.45__tar.gz

{freesolo-0.2.43 → freesolo-0.2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo
-Version: 0.2.43
+Version: 0.2.45
 Summary: Tracing, evaluation, and training utilities for LLM applications.
 Requires-Python: >=3.10
 Requires-Dist: typing-extensions>=4.8.0

{freesolo-0.2.43 → freesolo-0.2.45}/npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesolo/sdk",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "Tracing and evaluation utilities for TypeScript LLM applications.",
   "type": "module",
   "main": "./dist/index.js",

{freesolo-0.2.43 → freesolo-0.2.45}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freesolo/sdk",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "Tracing and evaluation utilities for LLM applications.",
   "type": "module",
   "main": "./npm/dist/index.js",

freesolo-0.2.45/pypi/freesolo/training/storage.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import Any
+
+from freesolo.utils.storage import FreesoloStorageClient
+
+TRAINING_RUN_ID_ENV = "FREESOLO_TRAINING_RUN_ID"
+
+
+@dataclass(frozen=True)
+class StoredTrainingRun:
+    """Handle to the platform run a training phase reports into.
+
+    When no platform run is attached (``client is None``), every method
+    no-ops so training works identically without storage sync.
+    """
+
+    client: FreesoloStorageClient | None
+    run_id: str | None
+
+    def link_wandb(self, wandb_url: str | None) -> None:
+        if self.client is None or self.run_id is None:
+            return
+        self.client.link_wandb(self.run_id, wandb_url)
+
+    def complete(self, config: dict[str, Any] | None = None) -> None:
+        """Record the phase's final config on the shared run.
+
+        Terminal status is platform-owned: the backend marks the run
+        completed/failed when the training job ends, so an SFT phase
+        finishing must not flip the shared run to completed while GRPO
+        is still ahead.
+        """
+        if self.client is None or self.run_id is None:
+            return
+        if config is not None:
+            self.client.update_run(self.run_id, config=config)
+
+    def fail(self, error: BaseException) -> None:
+        """Record the phase failure's error text on the shared run.
+
+        Status stays platform-owned (the job may retry the phase and
+        re-attach); the backend marks the run failed if the job fails.
+        """
+        if self.client is None or self.run_id is None:
+            return
+        with suppress(Exception):
+            # Preserve the original training exception for the caller.
+            self.client.update_run(self.run_id, error=str(error))
+
+
+def attach_stored_training_run(
+    *,
+    phase: str,
+    config: dict[str, Any] | None = None,
+) -> StoredTrainingRun:
+    """Attach to the platform run named by ``FREESOLO_TRAINING_RUN_ID``.
+
+    The platform owns run creation: it creates exactly one run per training
+    job, and every SFT/GRPO phase of that job attaches to it, so the run
+    accumulates each phase's status, config, and W&B links. Without the env
+    id (optimizer pilots, ad-hoc local runs) storage sync is disabled and
+    the returned handle no-ops.
+    """
+    run_id = os.getenv(TRAINING_RUN_ID_ENV, "").strip()
+    if not run_id:
+        return StoredTrainingRun(client=None, run_id=None)
+
+    client = FreesoloStorageClient()
+    client.update_run(
+        run_id,
+        status="running",
+        config={**(config or {}), "phase": phase},
+    )
+    return StoredTrainingRun(client=client, run_id=run_id)

{freesolo-0.2.43 → freesolo-0.2.45}/pypi/freesolo/training/train_grpo.py

@@ -29,7 +29,7 @@ from freesolo.training.grpo.sampling import (
     ensure_sampling_client,
     session_id_from_tinker_path,
 )
-from freesolo.training.storage import start_stored_training_run
+from freesolo.training.storage import attach_stored_training_run
 from freesolo.training.types import (
     DEFAULT_TRAINING_LORA_RANK,
     TRAINING_BASE_MODEL,
@@ -149,10 +149,8 @@ async def train_grpo_async(
         "record_count": len(examples),
         **tinker_run_config(resolved_tinker_base_url),
     }
-    stored_run = start_stored_training_run(
+    stored_run = attach_stored_training_run(
         phase="grpo",
-        name=run_name,
-        description="Freesolo GRPO training run",
         config=run_config,
     )
     wandb_run = None

{freesolo-0.2.43 → freesolo-0.2.45}/pypi/freesolo/training/train_sft.py

@@ -14,7 +14,7 @@ if __package__ in {None, ""}:
 from freesolo.contracts import ChatMessage, load_contract_text
 from freesolo.datasets import load_dataset
 from freesolo.environments.base import load_environment
-from freesolo.training.storage import start_stored_training_run
+from freesolo.training.storage import attach_stored_training_run
 from freesolo.training.types import (
     TRAINING_BASE_MODEL,
     SftConfig,
@@ -144,10 +144,8 @@ def _train_sft(
         "training_example_count": len(training_conversations),
         **tinker_run_config(resolved_tinker_base_url),
     }
-    stored_run = start_stored_training_run(
+    stored_run = attach_stored_training_run(
         phase="sft",
-        name=run_name,
-        description="Freesolo SFT training run",
         config=run_config,
     )
     wandb_run = None

{freesolo-0.2.43 → freesolo-0.2.45}/pypi/freesolo/utils/storage.py

@@ -106,34 +106,6 @@ class FreesoloStorageClient:
             )
         _json_response(response, AUTH_VERIFY_PATH)
 
-    def create_run(
-        self,
-        *,
-        name: str,
-        description: str | None = None,
-        version: str | None = None,
-        evaluator_ids: list[str] | tuple[str, ...] = (),
-        model_id: str | None = None,
-        config: dict[str, Any] | None = None,
-    ) -> str:
-        payload: JsonObject = {"name": require_non_empty(name, "name")}
-        if description:
-            payload["description"] = description
-        if version:
-            payload["version"] = version
-        if model_id:
-            payload["model_id"] = model_id
-        if evaluator_ids:
-            payload["evaluator_ids"] = [str(value) for value in evaluator_ids]
-        run_config = _training_run_config(config)
-        if run_config:
-            payload["config"] = run_config
-        data = self._post_json(
-            RUNS_PATH,
-            payload,
-        )
-        return _response_id(data, "run_id")
-
     def update_run(
         self,
         run_id: str,

{freesolo-0.2.43 → freesolo-0.2.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "freesolo"
-version = "0.2.43"
+version = "0.2.45"
 description = "Tracing, evaluation, and training utilities for LLM applications."
 readme = "README.md"
 requires-python = ">=3.10"

{freesolo-0.2.43 → freesolo-0.2.45}/tests/functionality/test_storage_sync.py

@@ -4,7 +4,7 @@ from typing import Any, ClassVar
 
 import httpx
 import pytest
-from freesolo.training.storage import start_stored_training_run
+from freesolo.training.storage import attach_stored_training_run
 from freesolo.utils.core import _auth_headers
 from freesolo.utils.storage import FreesoloStorageClient
 
@@ -139,7 +139,7 @@ def test_storage_client_sets_auth_headers(
     FreesoloStorageClient(
         api_key="fs-test",
         base_url="https://api.test",
-    ).create_run(name="train")
+    ).update_run("run-1", status="running")
 
     assert _FakeHttpClient.calls[0]["headers"] == _auth_headers("fs-test")
 
@@ -156,7 +156,7 @@ def test_storage_client_sets_internal_training_scope_headers(
         user_id="user-1",
         org_id="org-A",
         base_url="https://api.test",
-    ).create_run(name="train")
+    ).update_run("run-1", status="running")
 
     assert _FakeHttpClient.calls[0]["headers"] == {
         "Authorization": "Bearer internal-key",
@@ -216,28 +216,21 @@ def test_verify_api_key_rejects_unauthorized_response(
         ).verify_api_key()
 
 
-def test_run_create_update_and_wandb_use_freesolo_api(
+def test_run_update_and_wandb_use_freesolo_api(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setattr("freesolo.utils.storage.httpx.Client", _FakeHttpClient)
     client = FreesoloStorageClient(api_key="fs-test", base_url="https://api.test")
 
-    run_id = client.create_run(name="train")
-    client.update_run(run_id, status="running", config={"phase": "sft"})
-    client.link_wandb(run_id, "https://wandb.ai/o/p/runs/r")
+    client.update_run("run-1", status="running", config={"phase": "sft"})
+    client.link_wandb("run-1", "https://wandb.ai/o/p/runs/r")
 
-    assert run_id == "run-1"
     assert _FakeHttpClient.calls[0] == {
-        "url": "https://api.test/api/runs",
-        "headers": _auth_headers("fs-test"),
-        "json": {"name": "train"},
-    }
-    assert _FakeHttpClient.calls[1] == {
         "url": "https://api.test/api/runs/run-1",
         "headers": _auth_headers("fs-test"),
         "json": {"status": "running", "config": {"phase": "sft"}},
     }
-    assert _FakeHttpClient.calls[2] == {
+    assert _FakeHttpClient.calls[1] == {
         "url": "https://api.test/api/runs/run-1/wandb",
         "headers": _auth_headers("fs-test"),
         "json": {"wandb_url": "https://wandb.ai/o/p/runs/r"},
@@ -252,11 +245,10 @@ def test_run_config_includes_agent_job_context(
     monkeypatch.setenv("FREESOLO_TRAINING_TASK_ID", "task-1")
     client = FreesoloStorageClient(api_key="fs-test", base_url="https://api.test")
 
-    run_id = client.create_run(name="train", config={"phase": "sft"})
-    client.update_run(run_id, config={"phase": "grpo"})
+    client.update_run("run-1", config={"phase": "sft"})
+    client.update_run("run-1", config={"phase": "grpo"})
 
     assert _FakeHttpClient.calls[0]["json"] == {
-        "name": "train",
         "config": {
             "phase": "sft",
             "trainingAgentJobId": "job-1",
@@ -306,28 +298,28 @@ def test_storage_client_surfaces_http_error_body(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setattr("freesolo.utils.storage.httpx.Client", _FakeHttpClient)
-    _FakeHttpClient.status_by_suffix = {"/api/runs": 500}
-    _FakeHttpClient.text_by_suffix = {"/api/runs": "db unavailable"}
+    _FakeHttpClient.status_by_suffix = {"/api/runs/run-1": 500}
+    _FakeHttpClient.text_by_suffix = {"/api/runs/run-1": "db unavailable"}
 
     with pytest.raises(httpx.HTTPStatusError, match="db unavailable"):
         FreesoloStorageClient(
             api_key="fs-test",
             base_url="https://api.test",
-        ).create_run(name="train")
+        ).update_run("run-1", status="running")
 
 
 def test_storage_client_truncates_long_http_error_body(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setattr("freesolo.utils.storage.httpx.Client", _FakeHttpClient)
-    _FakeHttpClient.status_by_suffix = {"/api/runs": 500}
-    _FakeHttpClient.text_by_suffix = {"/api/runs": "x" * 2_500}
+    _FakeHttpClient.status_by_suffix = {"/api/runs/run-1": 500}
+    _FakeHttpClient.text_by_suffix = {"/api/runs/run-1": "x" * 2_500}
 
     with pytest.raises(httpx.HTTPStatusError) as exc_info:
         FreesoloStorageClient(
             api_key="fs-test",
             base_url="https://api.test",
-        ).create_run(name="train")
+        ).update_run("run-1", status="running")
 
     message = str(exc_info.value)
     assert message.count("x") == 2_000
@@ -338,69 +330,37 @@ def test_storage_client_rejects_missing_response_id(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setattr("freesolo.utils.storage.httpx.Client", _FakeHttpClient)
-    _FakeHttpClient.response_json_by_suffix = {"/api/runs": {"ok": True}}
+    _FakeHttpClient.response_json_by_suffix = {"/api/codex-logs": {"ok": True}}
 
-    with pytest.raises(ValueError, match="missing run_id"):
+    with pytest.raises(ValueError, match="missing codex_log_id"):
         FreesoloStorageClient(
             api_key="fs-test",
             base_url="https://api.test",
-        ).create_run(name="train")
+        ).append_codex_log("Draft agent started")
 
 
-def test_training_storage_creates_run(
+def test_training_storage_is_disabled_without_platform_run(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
+    """The platform owns run creation: without FREESOLO_TRAINING_RUN_ID the
+    handle no-ops instead of creating a run (or requiring credentials)."""
     monkeypatch.delenv("FREESOLO_TRAINING_RUN_ID", raising=False)
 
-    class FakeStorageClient:
-        def __init__(self) -> None:
-            self.calls: list[tuple[str, dict[str, Any]]] = []
-            created_clients.append(self)
-
-        def create_run(self, **kwargs: Any) -> str:
-            self.calls.append(("create_run", kwargs))
-            return "run-1"
-
-        def update_run(self, run_id: str, **kwargs: Any) -> None:
-            self.calls.append(("update_run", {"run_id": run_id, **kwargs}))
+    def _fail_client(*_args: Any, **_kwargs: Any) -> None:
+        raise AssertionError("storage client must not be constructed when disabled")
 
-    created_clients: list[FakeStorageClient] = []
-    monkeypatch.setattr(
-        "freesolo.training.storage.FreesoloStorageClient", FakeStorageClient
-    )
+    monkeypatch.setattr("freesolo.training.storage.FreesoloStorageClient", _fail_client)
 
-    stored = start_stored_training_run(
+    stored = attach_stored_training_run(
         phase="grpo",
-        name="full train",
-        description="long training",
         config={"learning_rate": 1e-5},
     )
 
-    assert stored.run_id == "run-1"
-    assert created_clients[0].calls == [
-        (
-            "create_run",
-            {
-                "name": "full train",
-                "description": "long training",
-                "config": {
-                    "learning_rate": 1e-5,
-                    "phase": "grpo",
-                },
-            },
-        ),
-        (
-            "update_run",
-            {
-                "run_id": "run-1",
-                "status": "running",
-                "config": {
-                    "learning_rate": 1e-5,
-                    "phase": "grpo",
-                },
-            },
-        ),
-    ]
+    assert stored.run_id is None
+    assert stored.client is None
+    stored.link_wandb("https://wandb.ai/acme/proj/runs/run-1")
+    stored.complete(config={"final": True})
+    stored.fail(RuntimeError("boom"))
 
 
 def test_training_storage_reuses_worker_run_id(
@@ -411,10 +371,6 @@ def test_training_storage_reuses_worker_run_id(
             self.calls: list[tuple[str, dict[str, Any]]] = []
             created_clients.append(self)
 
-        def create_run(self, **kwargs: Any) -> str:
-            self.calls.append(("create_run", kwargs))
-            return "new-run"
-
         def update_run(self, run_id: str, **kwargs: Any) -> None:
             self.calls.append(("update_run", {"run_id": run_id, **kwargs}))
 
@@ -424,9 +380,8 @@ def test_training_storage_reuses_worker_run_id(
         "freesolo.training.storage.FreesoloStorageClient", FakeStorageClient
     )
 
-    stored = start_stored_training_run(
+    stored = attach_stored_training_run(
         phase="sft",
-        name="full train",
         config={"learning_rate": 1e-5},
     )
 
@@ -441,21 +396,17 @@ def test_training_storage_reuses_worker_run_id(
                 "config": {
                     "learning_rate": 1e-5,
                     "phase": "sft",
-                    "platformRunId": "run-from-worker",
                 },
             },
         ),
-        (
-            "update_run",
-            {
-                "run_id": "run-from-worker",
-                "status": "completed",
-            },
-        ),
     ]
 
 
-def test_stored_training_run_complete_and_fail_update_status() -> None:
+def test_stored_training_run_never_sets_terminal_status() -> None:
+    """Phases stream config/W&B/errors; the platform terminalizes the run
+    when the job ends, so a finished SFT phase cannot mark the shared run
+    completed while GRPO is still ahead."""
+
     class FakeClient:
         def __init__(self) -> None:
             self.calls: list[tuple[str, dict[str, Any]]] = []
@@ -473,10 +424,12 @@ def test_stored_training_run_complete_and_fail_update_status() -> None:
 
     stored.link_wandb("https://wandb.ai/o/p/runs/r")
     stored.complete()
+    stored.complete(config={"final_checkpoint": "tinker://final"})
     stored.fail(RuntimeError("boom"))
 
     assert client.calls == [
         ("run-1", {"wandb_url": "https://wandb.ai/o/p/runs/r"}),
-        ("run-1", {"status": "completed"}),
-        ("run-1", {"status": "failed", "error": "boom"}),
+        ("run-1", {"config": {"final_checkpoint": "tinker://final"}}),
+        ("run-1", {"error": "boom"}),
     ]
+    assert not any("status" in call[1] for call in client.calls)

{freesolo-0.2.43 → freesolo-0.2.45}/uv.lock

@@ -572,7 +572,7 @@ wheels = [
 
 [[package]]
 name = "freesolo"
-version = "0.2.43"
+version = "0.2.45"
 source = { editable = "." }
 dependencies = [
     { name = "typing-extensions" },

freesolo-0.2.43/pypi/freesolo/training/storage.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import os
-from contextlib import suppress
-from dataclasses import dataclass
-from typing import Any
-
-from freesolo.utils.storage import FreesoloStorageClient
-
-TRAINING_RUN_ID_ENV = "FREESOLO_TRAINING_RUN_ID"
-
-
-@dataclass(frozen=True)
-class StoredTrainingRun:
-    client: FreesoloStorageClient
-    run_id: str
-
-    def link_wandb(self, wandb_url: str | None) -> None:
-        self.client.link_wandb(self.run_id, wandb_url)
-
-    def complete(self, config: dict[str, Any] | None = None) -> None:
-        if config is None:
-            self.client.update_run(self.run_id, status="completed")
-        else:
-            self.client.update_run(self.run_id, status="completed", config=config)
-
-    def fail(self, error: BaseException) -> None:
-        with suppress(Exception):
-            # Preserve the original training exception for the caller.
-            self.client.update_run(self.run_id, status="failed", error=str(error))
-
-
-def start_stored_training_run(
-    *,
-    phase: str,
-    name: str,
-    description: str | None = None,
-    config: dict[str, Any] | None = None,
-) -> StoredTrainingRun:
-    client = FreesoloStorageClient()
-    initial_config = {
-        **(config or {}),
-        "phase": phase,
-    }
-    existing_run_id = os.getenv(TRAINING_RUN_ID_ENV, "").strip()
-    if existing_run_id:
-        initial_config.setdefault("platformRunId", existing_run_id)
-        client.update_run(
-            existing_run_id,
-            status="running",
-            config=initial_config,
-        )
-        return StoredTrainingRun(
-            client=client,
-            run_id=existing_run_id,
-        )
-
-    run_id = client.create_run(
-        name=name,
-        description=description,
-        config=initial_config,
-    )
-    client.update_run(
-        run_id,
-        status="running",
-        config=initial_config,
-    )
-    return StoredTrainingRun(client=client, run_id=run_id)