skillflow-py 1.4.2__tar.gz → 1.4.3__tar.gz

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.4.2
+Version: 1.4.3
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillflow-py"
-version = "1.4.2"
+version = "1.4.3"
 description = "Config-agnostic LLM pipeline graph executor — turn skills into flows"
 readme = "README.md"
 license = "MIT"

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/src/skillflow/core.py

@@ -1286,29 +1286,44 @@ class SkillFlow:
                                      hook_name: str, items: list) -> dict:
         """Run a list of tool hooks in order (e.g. repo_apply then repo_delete).
 
-        Each item is a ``{'tool', 'params', 'on_failure'?}`` dict executed via
-        :meth:`_execute_tool_hook` (full variable resolution + project_root
-        injection). Per-item ``on_failure`` is honored: ``warn``/``skip`` log and
-        continue to the next item; ``retry``/``fail`` stop the sequence and
-        bubble up (carrying the item's ``on_failure``) so the caller applies the
-        right step-level outcome.
+        Each item is a ``{'tool', 'params', 'on_failure'?, 'max_retries'?}`` dict
+        executed via :meth:`_execute_tool_hook` (full variable resolution +
+        project_root injection). Per-item policy is honored IN PLACE:
+        ``on_failure: retry`` re-runs THAT item up to its own ``max_retries``
+        (without re-running earlier, already-succeeded items or the agent step);
+        ``warn``/``skip`` log and continue to the next item; ``fail`` (or a retry
+        item that exhausts its retries) stops the sequence and fails the step.
+        The sequence never bubbles ``retry`` to the caller — that would reset the
+        whole agent step and re-execute earlier, already-committed items.
         """
         detail_files = None
         for item in items:
             if not (isinstance(item, dict) and "tool" in item):
                 return {"passed": False,
                         "error": f"Invalid tool hook in '{hook_name}': {item!r}"}
-            res = self._execute_tool_hook(token, node, hook_name, item)
+            on_failure = item.get("on_failure", "fail")
+            max_retries = int(item.get("max_retries", 0) or 0)
+            res = {"passed": False}
+            for attempt in range(max_retries + 1):
+                res = self._execute_tool_hook(token, node, hook_name, item)
+                if res.get("passed", True):
+                    break
+                if on_failure == "retry" and attempt < max_retries:
+                    # Retry THIS item in place — do not re-run earlier items.
+                    self._emit_lifecycle_event(
+                        token, hook_name, "retry", res.get("error", ""))
+                    continue
+                break
             if not res.get("passed", True):
-                on_failure = item.get("on_failure", "fail")
                 if on_failure in ("warn", "skip"):
                     self._emit_lifecycle_event(
                         token, hook_name,
                         "warned" if on_failure == "warn" else "skipped",
                         res.get("error", ""))
                     continue
-                # retry / fail: stop and let the caller apply the step outcome.
-                return {**res, "on_failure": on_failure}
+                # 'fail', or a 'retry' item that exhausted max_retries → fail the
+                # step (never bubble 'retry', which re-runs the whole sequence).
+                return {**res, "on_failure": "fail"}
             files = res.get("files")
             if isinstance(files, list):
                 detail_files = files
@@ -2326,10 +2341,12 @@ class SkillFlow:
         so it retries promptly instead of stalling until its claim times out.
 
         Capped at 3 crashes: a tool that crashes deterministically is broken,
-        not transient, so relaunching it every tick just rampages until the
-        host's step-count valve trips. The SF-20 stale-recovery cap does NOT
-        cover this path (a crash reopens directly, never via
-        recover_stale_claims), so track the count here and fail after 3.
+        not transient. On the 3rd crash the RUN is failed (not just the step) —
+        marking only the step failed + current_node=NULL would let advance_run
+        re-resolve back to the tool and open a FRESH instance with a reset
+        counter, so the crash loop never actually stopped (only the host's
+        step-count valve caught it). The SF-20 stale-recovery cap does NOT cover
+        this path (a crash reopens directly, never via recover_stale_claims).
         """
         with self._tx() as conn:
             row = conn.execute(
@@ -2353,11 +2370,9 @@ class SkillFlow:
                     "claimed_by = NULL, updated_at = datetime('now') WHERE id = ?",
                     (error_msg, row["id"]),
                 )
-                conn.execute(
-                    "UPDATE skillflow_runs SET current_node = NULL, "
-                    "updated_at = datetime('now') WHERE id = ?",
-                    (run_id,),
-                )
+                # Fail the RUN so advance_run returns None instead of re-resolving
+                # the predecessor's transition and opening a fresh tool instance.
+                self._fail_run_in_tx(conn, run_id, error_msg)
                 self.notifications.publish_sync(
                     "step_failed",
                     {"run_id": run_id, "step_id": step_id,
@@ -2984,10 +2999,14 @@ class SkillFlow:
                 try:
                     node = self._get_resolver_for_run(
                         row["run_id"]).get_node(row["step_id"])
-                    if (node and node.step_type == "tool"
-                            and node.timeout_seconds
-                            and node.timeout_seconds > window):
-                        window = float(node.timeout_seconds)
+                    if node and node.step_type == "tool":
+                        if node.timeout_seconds == 0:
+                            # 0 = "no timeout": a live tool may run arbitrarily
+                            # long, so it is NEVER stale — reclaiming it would
+                            # relaunch it concurrently with itself (the rampage).
+                            continue
+                        if node.timeout_seconds > window:
+                            window = float(node.timeout_seconds)
                 except Exception:
                     pass
                 threshold = time.strftime(

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/src/skillflow_py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skillflow-py
-Version: 1.4.2
+Version: 1.4.3
 Summary: Config-agnostic LLM pipeline graph executor — turn skills into flows
 Author: Skillflow contributors
 License-Expression: MIT

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/tests/test_core.py

@@ -1247,6 +1247,57 @@ def test_on_deliver_list_order_and_on_failure(sf: SkillFlow, tmp_path: Path,
     assert calls == []
 
 
+def test_on_deliver_item_retries_in_place(sf: SkillFlow, tmp_path: Path,
+                                          monkeypatch):
+    """A failing on_deliver item with on_failure=retry re-runs THAT item up to
+    its own max_retries IN PLACE; earlier items are not re-run, and the sequence
+    never bubbles 'retry' to the caller (which would reset the whole step)."""
+    sf._tool_loader = ToolLoader(
+        Path(__file__).parent.parent / "src" / "skillflow" / "tools")
+    sf._workspace = WorkspaceManager(str(tmp_path / "ws"),
+                                     projects_base=str(tmp_path / "proj"))
+    node = StepNode(id="s1", step_type="agent", output_mode="content",
+                    output_fixed={"out": "r.md"}, transitions=[Transition(to=None)])
+    sf.register_graph(PipelineGraph(name="seq", begin="s1", steps=[node]))
+    rid = sf.create_run("seq", {"project_id": "pid"})
+    sf.start_run(rid)
+    sf.advance_run(rid)
+    token = sf.claim_next_step(rid).token
+
+    calls: list = []
+
+    # 'flaky' fails its first 2 attempts, succeeds on the 3rd.
+    def fake(tok, nd, hook_name, spec):
+        calls.append(spec["tool"])
+        if spec["tool"] == "flaky":
+            return {"passed": calls.count("flaky") >= 3}
+        return {"passed": True}
+    monkeypatch.setattr(sf, "_execute_tool_hook", fake)
+
+    r = sf._execute_lifecycle_hook(token, node, "on_deliver", [
+        {"tool": "repo_apply"},
+        {"tool": "flaky", "on_failure": "retry", "max_retries": 3},
+    ])
+    # repo_apply ran ONCE (not re-run while flaky retried); flaky retried in place.
+    assert calls == ["repo_apply", "flaky", "flaky", "flaky"]
+    assert r["passed"] is True
+
+    # Exhausted retries → fail the STEP, never bubble 'retry'.
+    calls.clear()
+
+    def always_fail(tok, nd, hook_name, spec):
+        calls.append(spec["tool"])
+        return {"passed": spec["tool"] != "boom"}
+    monkeypatch.setattr(sf, "_execute_tool_hook", always_fail)
+    r = sf._execute_lifecycle_hook(token, node, "on_deliver", [
+        {"tool": "repo_apply"},
+        {"tool": "boom", "on_failure": "retry", "max_retries": 2},
+    ])
+    assert calls == ["repo_apply", "boom", "boom", "boom"]  # 1 initial + 2 retries
+    assert r["passed"] is False
+    assert r.get("on_failure") == "fail"   # NOT "retry" — no whole-step re-run
+
+
 # ── Durable run trace ─────────────────────────────────────────────────
 
 def test_trace_append_and_get(sf: SkillFlow):

{skillflow_py-1.4.2 → skillflow_py-1.4.3}/tests/test_recovery.py

@@ -1,17 +1,84 @@
 """Unit tests for recovery.py."""
 
 import time
+from pathlib import Path
 
 import pytest
 
 from skillflow.core import SkillFlow
 from skillflow.graph import PipelineGraph, StepNode, Transition
+from skillflow.tool_loader import ToolLoader
+from skillflow.workspace import WorkspaceManager
+
+_REAL_TOOLS = Path(__file__).parent.parent / "src" / "skillflow" / "tools"
 
 
 def _agent(id: str, transitions=None):
     return StepNode(id=id, step_type="agent", transitions=transitions or [])
 
 
+def test_recover_never_reclaims_tool_with_zero_timeout(sf: SkillFlow):
+    """A tool node with timeout_seconds=0 ('no timeout') is never reclaimed,
+    however old the claim — reclaiming a live no-timeout tool would relaunch it
+    concurrently with itself (the rampage)."""
+    graph = PipelineGraph(
+        name="test", begin="a",
+        steps=[StepNode(id="a", step_type="tool", tool_name="write",
+                        timeout_seconds=0, transitions=[])],
+    )
+    sf.register_graph(graph)
+    run_id = sf.create_run("test")
+    sf.start_run(run_id)
+    long_ago = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(time.time() - 99999))
+    with sf._lock:
+        sf._conn.execute(
+            "INSERT INTO skillflow_steps (run_id, step_id, step_config_json, "
+            "inputs_json, max_retries, status, claimed_at, created_at, updated_at) "
+            "VALUES (?, 'a', '{}', '{}', 3, 'claimed', ?, "
+            "datetime('now'), datetime('now'))",
+            (run_id, long_ago))
+        sf._conn.commit()
+    # Claimed 99999s ago, but timeout_seconds=0 → never stale.
+    assert sf.recover_stale_claims(stale_threshold_seconds=60) == []
+    st = sf._conn.execute(
+        "SELECT status FROM skillflow_steps WHERE run_id=? AND step_id='a' "
+        "ORDER BY id DESC LIMIT 1", (run_id,)).fetchone()
+    assert st["status"] == "claimed"
+
+
+def test_tool_crash_fails_run_after_three(sf: SkillFlow, tmp_path,
+                                          monkeypatch):
+    """A tool that crashes on EVERY execution fails the RUN after 3 crashes,
+    instead of looping forever via advance_run re-resolving into fresh instances
+    (regression: the per-instance _tool_reopen_count was reset each time
+    _claim_tool_step_in_tx opened a new instance)."""
+    sf._tool_loader = ToolLoader(_REAL_TOOLS)
+    sf._workspace = WorkspaceManager(str(tmp_path / "ws"),
+                                     projects_base=str(tmp_path / "proj"))
+    node = StepNode(id="boom", step_type="tool", tool_name="write",
+                    transitions=[Transition(to=None)])
+    sf.register_graph(PipelineGraph(name="crash", begin="boom", steps=[node]))
+    run_id = sf.create_run("crash", {"project_id": "p"})
+    sf.start_run(run_id)
+
+    def _boom(*a, **k):
+        raise RuntimeError("boom")
+    monkeypatch.setattr(sf, "_execute_tool_inline", _boom)
+
+    for _ in range(25):
+        try:
+            sf.advance_run(run_id)   # tool fast-path reopens then re-raises
+        except RuntimeError:
+            pass
+        if sf.get_run(run_id)["status"] == "failed":
+            break
+    assert sf.get_run(run_id)["status"] == "failed"
+    n = sf._conn.execute(
+        "SELECT COUNT(*) c FROM skillflow_steps WHERE run_id=? AND step_id='boom'",
+        (run_id,)).fetchone()["c"]
+    assert n == 1, f"crash should fail the run after 1 instance x3, got {n}"
+
+
 def test_recover_respects_tool_timeout_seconds(sf: SkillFlow):
     """A TOOL step claimed longer than the flat threshold but WITHIN its
     timeout_seconds is NOT reclaimed — a slow-but-alive tool (run_tests,