Add deepagents_rl package sources

src/deepagents_rl/train/swe_env.py

@@ -19,6 +19,24 @@ from pathlib import Path
 from typing import Any, Callable
 
 
+def _vlog(msg: str, **fields: Any) -> None:
+    """Always-on verbose progress (Kaggle logs + local stderr)."""
+    extra = ""
+    if fields:
+        try:
+            extra = " | " + json.dumps(fields, default=str)[:1200]
+        except Exception:
+            extra = f" | {fields!r}"[:1200]
+    line = f"[darl] {msg}{extra}"
+    print(line, flush=True)
+    try:
+        from deepagents_rl.observability.logging import step
+
+        step("swe_env", msg, **fields)
+    except Exception:
+        pass
+
+
 def _result_to_str(obj: Any) -> str:
     if obj is None:
         return ""
@@ -97,9 +115,26 @@ def grade_patch_remote(
         "model_patch": model_patch or "",
         "timeout_s": timeout_s,
     }
+    _vlog(
+        "grader.POST /grade",
+        url=base,
+        instance_id=instance_id,
+        patch_bytes=len((model_patch or "").encode("utf-8")),
+        timeout_s=timeout_s,
+    )
     resp = requests.post(f"{base}/grade", headers=headers, json=payload, timeout=timeout_s + 60)
+    _vlog("grader.response", status=resp.status_code, body_preview=(resp.text or "")[:400])
     resp.raise_for_status()
-    return resp.json()
+    data = resp.json()
+    _vlog(
+        "grader.result",
+        instance_id=instance_id,
+        reward_total=data.get("reward_total"),
+        resolution=data.get("resolution"),
+        resolved=data.get("resolved"),
+        error=data.get("error"),
+    )
+    return data
 
 
 def _traced_tool(method: Callable[..., str]) -> Callable[..., str]:
@@ -175,10 +210,25 @@ class DeepAgentSWEEnv:
         kwargs: dict[str, Any],
     ) -> str:
         payload = _truncate({"args": list(args), "kwargs": kwargs})
+        n = len(self._tool_calls) + 1
+        _vlog(
+            f"tool[{n}].begin {name}",
+            instance_id=self._task.get("instance_id"),
+            rollout_id=self._rollout_id,
+            input=payload,
+        )
         lf = self._lf
         if lf is None or self._root is None:
-            out = method(self, *args, **kwargs)
+            try:
+                out = method(self, *args, **kwargs)
+            except Exception as e:  # noqa: BLE001
+                out = f"TOOL_ERROR: {type(e).__name__}: {e}"
             self._tool_calls.append({"name": name, "input": payload, "output": _truncate(out)})
+            _vlog(
+                f"tool[{n}].end {name}",
+                output_preview=str(out)[:500],
+                output_chars=len(str(out)),
+            )
             return out
 
         with lf.start_as_current_observation(
@@ -189,18 +239,22 @@ class DeepAgentSWEEnv:
                 "rollout_id": self._rollout_id,
                 "instance_id": self._task.get("instance_id"),
                 "harness": "deepagents-swe-grpo",
+                "tool_index": n,
             },
         ) as span:
             try:
                 out = method(self, *args, **kwargs)
                 span.update(output=_truncate(out))
-                self._tool_calls.append({"name": name, "input": payload, "output": _truncate(out)})
-                return out
             except Exception as e:  # noqa: BLE001
-                err = f"TOOL_ERROR: {type(e).__name__}: {e}"
-                span.update(output=err, level="ERROR")
-                self._tool_calls.append({"name": name, "input": payload, "output": err})
-                return err
+                out = f"TOOL_ERROR: {type(e).__name__}: {e}"
+                span.update(output=out, level="ERROR")
+            self._tool_calls.append({"name": name, "input": payload, "output": _truncate(out)})
+            _vlog(
+                f"tool[{n}].end {name}",
+                output_preview=str(out)[:500],
+                output_chars=len(str(out)),
+            )
+            return out
 
     def reset(self, **kwargs: Any) -> None:
         """Materialize repo sandbox from a SWE Lite row. Prompt stays on the dataset."""
@@ -223,6 +277,14 @@ class DeepAgentSWEEnv:
             else kwargs.get("pass_to_pass_json")
         )
 
+        _vlog(
+            "env.reset.begin",
+            instance_id=instance_id,
+            repo=repo,
+            base_commit=(base_commit[:12] if base_commit else ""),
+            keys=list(kwargs.keys())[:30],
+        )
+
         if not instance_id or not repo or not base_commit:
             raise ValueError(
                 f"DeepAgentSWEEnv.reset requires instance_id/repo/base_commit; got keys={list(kwargs)}"
@@ -252,6 +314,7 @@ class DeepAgentSWEEnv:
         self._trace_id = ""
 
         lf = self._ensure_langfuse()
+        _vlog("env.reset.langfuse", enabled=lf is not None)
         if lf is not None:
             try:
                 self._root_cm = lf.start_as_current_observation(
@@ -282,12 +345,14 @@ class DeepAgentSWEEnv:
                 )
                 self._root = self._root_cm.__enter__()
                 self._trace_id = lf.get_current_trace_id() or ""
+                _vlog("env.reset.langfuse_trace", trace_id=self._trace_id)
             except Exception as e:  # noqa: BLE001
-                print(f"[langfuse] start rollout failed: {e}")
+                _vlog("env.reset.langfuse_failed", error=str(e))
                 self._root_cm = None
                 self._root = None
 
         def _materialize() -> None:
+            _vlog("env.reset.materialize", repo=repo, base_commit=base_commit[:12])
             self._sandbox_parent = Path(
                 tempfile.mkdtemp(prefix=f"darl_grpo_{instance_id[:40]}_")
             )
@@ -298,6 +363,7 @@ class DeepAgentSWEEnv:
                 virtual_mode=True,
                 timeout=60,
             )
+            _vlog("env.reset.sandbox_ready", sandbox=str(self._sandbox))
 
         if lf is not None and self._root is not None:
             with lf.start_as_current_observation(
@@ -309,6 +375,13 @@ class DeepAgentSWEEnv:
                 span.update(output={"sandbox": str(self._sandbox)})
         else:
             _materialize()
+        _vlog(
+            "env.reset.done",
+            instance_id=instance_id,
+            rollout_id=self._rollout_id,
+            n_f2p=len(fail_to_pass),
+            n_p2p=len(pass_to_pass),
+        )
         return None
 
     def _cleanup(self) -> None:
@@ -423,23 +496,39 @@ class DeepAgentSWEEnv:
         lf = self._lf
         reward = 0.0
         report: dict[str, Any] = {}
+        _vlog(
+            "env.get_reward.begin",
+            instance_id=self._task.get("instance_id"),
+            n_tool_calls=len(self._tool_calls),
+            tools_used=[c.get("name") for c in self._tool_calls],
+        )
 
         def _grade() -> float:
             nonlocal report
             if self._sandbox is None:
                 report = {"error": "no_sandbox", "reward_total": 0.0}
+                _vlog("env.get_reward.no_sandbox")
                 return 0.0
 
             from deepagents_rl.harness.repo import git_diff_patch
 
             try:
+                _vlog("env.get_reward.git_diff")
                 model_patch = git_diff_patch(self._sandbox)
+                _vlog(
+                    "env.get_reward.patch",
+                    patch_bytes=len(model_patch.encode("utf-8")),
+                    empty=not bool(model_patch.strip()),
+                    preview=model_patch[:300],
+                )
             except Exception as e:  # noqa: BLE001
                 report = {"error": f"git_diff_failed: {e}"}
+                _vlog("env.get_reward.git_diff_failed", error=str(e))
                 return 0.0
 
             if not model_patch.strip():
                 report = {"error": "empty_model_patch", "reward_total": 0.0}
+                _vlog("env.get_reward.empty_patch")
                 return 0.0
 
             try:
@@ -456,6 +545,7 @@ class DeepAgentSWEEnv:
                     "error": f"grader_failed: {e}",
                     "traceback": traceback.format_exc()[-1500:],
                 }
+                _vlog("env.get_reward.grader_failed", error=str(e))
                 return 0.0
 
             return float(report.get("reward_total") or 0.0)
@@ -513,6 +603,16 @@ class DeepAgentSWEEnv:
 
         self._last_report = report
         self._last_reward = reward
+        _vlog(
+            "env.get_reward.done",
+            instance_id=self._task.get("instance_id"),
+            reward_total=reward,
+            pass_frac=report.get("pass_frac"),
+            resolution=report.get("resolution"),
+            resolved=report.get("resolved"),
+            error=report.get("error"),
+            n_tool_calls=len(self._tool_calls),
+        )
 
         # W&B: one point per completed rollout (train + ckpt eval)
         try:
@@ -532,10 +632,12 @@ class DeepAgentSWEEnv:
                         "rollout/grader_error": str(report.get("error") or ""),
                     }
                 )
-        except Exception:
-            pass
+                _vlog("env.get_reward.wandb_logged")
+        except Exception as e:  # noqa: BLE001
+            _vlog("env.get_reward.wandb_failed", error=str(e))
 
         self._end_trace()
+        _vlog("env.get_reward.trace_closed", trace_id=self._trace_id)
         return reward