power-loop 6.46.0__tar.gz → 6.46.2__tar.gz

{power_loop-6.46.0 → power_loop-6.46.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-loop
-Version: 6.46.0
+Version: 6.46.2
 Summary: Embeddable agent execution kernel — LLM loop, hooks, events, tools, dynamic sub-agents.
 Author-email: zhangran <zhangran24@126.com>
 License: MIT

{power_loop-6.46.0 → power_loop-6.46.2}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "6.46.0"
+__version__ = "6.46.2"
 
 # Public LLM contract (SDK-free) re-exported so callers (e.g. writing llm.* hooks or
 # a custom LLMService) don't reach into the internal vendored transport package (H3.4).

{power_loop-6.46.0 → power_loop-6.46.2}/power_loop/workflow/engine.py

@@ -31,6 +31,7 @@ import asyncio
 import json
 import logging
 import re
+from collections import ChainMap
 from collections.abc import Awaitable, Callable
 from contextvars import ContextVar
 from dataclasses import replace
@@ -58,6 +59,37 @@ from .spec import (
 #: 循环信息在 env 里的键（模板变量正则匹配不到它，不会被当成 {{变量}}）
 _LOOP_KEY = "\x00loop"
 
+#: 当前 foreach 迭代自己的结果表（6.46.1）。body 的节点在每次迭代里 id 都一样，并行迭代共用全局结果表时，
+#: 体内的 inputs_from / when / 循环的 until 会读到别的迭代的结果。每个迭代在自己的 task 里开一层，嵌套的迭代再往里叠一层。
+_ITER_SCOPE: ContextVar[ChainMap[str, AgentResult] | None] = ContextVar("pl_wf_iter_scope", default=None)
+
+
+class _ScopedResults(dict):
+    """节点结果表：写的时候全局和当前迭代都写；读的时候先看当前迭代（再往外层迭代），最后看全局。
+    ``dict(self)`` / ``.items()`` 拿到的是全局那份（run 结果、journal 用）。"""
+
+    def __setitem__(self, key: str, value: AgentResult) -> None:
+        super().__setitem__(key, value)
+        scope = _ITER_SCOPE.get()
+        if scope is not None:
+            scope[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        scope = _ITER_SCOPE.get()
+        if scope is not None and key in scope:
+            return scope[key]
+        return super().get(key, default)
+
+    def __getitem__(self, key: str) -> AgentResult:
+        scope = _ITER_SCOPE.get()
+        if scope is not None and key in scope:
+            return scope[key]
+        return super().__getitem__(key)
+
+    def __contains__(self, key: object) -> bool:
+        scope = _ITER_SCOPE.get()
+        return (scope is not None and key in scope) or super().__contains__(key)
+
 __all__ = ["Executor", "InProcessExecutor", "WorkflowEngine", "WorkflowRunError", "in_workflow"]
 
 logger = logging.getLogger(__name__)
@@ -329,7 +361,8 @@ class WorkflowEngine:
         # Stable id for this run; threaded into each leaf's metadata as an
         # idempotency key so side-effecting tools can dedupe across a resume.
         self._run_id = run_id
-        self._results: dict[str, AgentResult] = {}
+        self._results: dict[str, AgentResult] = _ScopedResults()
+        self._iter_broken: list[str] = []
         self._errors: list[str] = []
         self._last: AgentResult | None = None
         self._budget_hit = False
@@ -403,10 +436,12 @@ class WorkflowEngine:
                     nid for nid, r in self._results.items()
                     if r.status not in ("completed", "skipped") and nid not in self._tolerated
                 ]
+                # foreach 各路里没成功的（全局表里只留了最后写的那一路，见 _iter_broken）
+                broken += [b for b in self._iter_broken if b.rsplit(".", 1)[-1] not in self._tolerated]
                 if broken:
                     status = "failed"
                     self._errors.append(
-                        "failed node(s): " + ", ".join(sorted(broken))
+                        "failed node(s): " + ", ".join(sorted(set(broken)))
                         + "（如果这些失败是可接受的，给对应节点加 continue_on_error: true）"
                     )
             if self._leaf_cap_hit and status == "completed":
@@ -999,10 +1034,20 @@ class WorkflowEngine:
             # ITERATION_ENV_KEY：body 的所有迭代共享同一个 node_id，宿主的 FileIO 端口靠它
             # 给每次迭代分不同的产出文件——不区分的话 N 个并发迭代会追加进同一个文件，互相搅乱。
             child_env = {**env, node.as_var: item, ITERATION_ENV_KEY: index}
-            if node.parallel:
-                async with sem:
-                    return await self._exec(node.body, child_env, driver_sid)
-            return await self._exec(node.body, child_env, driver_sid)
+            outer = _ITER_SCOPE.get()
+            scope: ChainMap[str, AgentResult] = ChainMap() if outer is None else outer.new_child()
+            tok = _ITER_SCOPE.set(scope)
+            try:
+                if node.parallel:
+                    async with sem:
+                        return await self._exec(node.body, child_env, driver_sid)
+                return await self._exec(node.body, child_env, driver_sid)
+            finally:
+                _ITER_SCOPE.reset(tok)
+                # 这一路里没成功的节点（6.46.1）：全局结果表里体内 id 只留最后写的那一路，run 终态要看每一路
+                for nid, r in scope.maps[0].items():
+                    if r.status not in ("completed", "skipped") and nid not in self._tolerated:
+                        self._iter_broken.append(f"{node.id or 'foreach'}[{index}].{nid}")
 
         # Per-iteration leaves are not journaled individually (see _emit_step);
         # the aggregate below is the resume unit. Reset even if a body raises.

{power_loop-6.46.0 → power_loop-6.46.2}/power_loop/workflow/spec.py

@@ -667,7 +667,8 @@ def _reach_pass(
     if isinstance(node, ForeachNode):
         if node.items_from:
             _need(node.items_from, f"{path}: items_from")
-        _reach_pass(node.body, set(available), refset, problems, f"{path}.body")  # body is isolated
+        # body 每次迭代自成一体：体内可以引用体内先跑完的节点，体外看不到体内
+        _reach_pass(node.body, set(available), refset | _local_ids(node.body), problems, f"{path}.body")
         return {node.id} if node.id else set()
     if isinstance(node, LoopNode):
         # 循环体至少跑一轮：它产出的 id 在 until 判断时和循环之后都可用
@@ -679,6 +680,26 @@ def _reach_pass(
     return set()
 
 
+def _local_ids(node: WorkflowNode) -> set[str]:
+    """一个（已解析的）子树里能被同层引用的 id：agent / foreach 聚合 / loop，不进更里层 foreach 的体。"""
+    out: set[str] = set()
+    if isinstance(node, AgentNode):
+        return {node.id} if node.id else out
+    if isinstance(node, ForeachNode):
+        return {node.id} if node.id else out
+    if isinstance(node, LoopNode):
+        out.add(node.id)
+        return out | _local_ids(node.body)
+    for child in (getattr(node, "steps", None) or getattr(node, "branches", None) or ()):
+        out |= _local_ids(child)
+    if isinstance(node, BranchNode):
+        for c in node.cases.values():
+            out |= _local_ids(c)
+        if node.default is not None:
+            out |= _local_ids(node.default)
+    return out
+
+
 def _parse_node(
     data: Any, path: str, problems: list[str], ids: set[str], body_ids: set[str]
 ) -> WorkflowNode | None:
@@ -1092,7 +1113,11 @@ def _parse_foreach(
     if "body" not in data:
         problems.append(f"{path}: foreach requires 'body'")
     else:
-        body = _parse_node(data["body"], f"{path}.body", problems, ids, body_ids)
+        # 体内的节点可以引用同一个体里的节点（6.46.1：每次迭代有自己的结果表，引擎按迭代取值，不会串）；
+        # 体外仍然只能引用 foreach 的聚合 id。更里一层 foreach 的体照旧不对这一层开放。
+        local: set[str] = set()
+        _collect_referenceable_ids(data["body"], local, in_body=False)
+        body = _parse_node(data["body"], f"{path}.body", problems, ids | local, body_ids - local)
     if body is None:
         return None
     return ForeachNode(

{power_loop-6.46.0 → power_loop-6.46.2}/power_loop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-loop
-Version: 6.46.0
+Version: 6.46.2
 Summary: Embeddable agent execution kernel — LLM loop, hooks, events, tools, dynamic sub-agents.
 Author-email: zhangran <zhangran24@126.com>
 License: MIT