power-loop 6.44.0__tar.gz → 6.45.0__tar.gz

{power_loop-6.44.0 → power_loop-6.45.0}/PKG-INFO

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

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "6.44.0"
+__version__ = "6.45.0"
 
 # 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.44.0 → power_loop-6.45.0}/power_loop/runtime/spec.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import contextlib
 import json
 import re
+from contextvars import ContextVar
 from dataclasses import dataclass, field, fields, replace
 from typing import Any
 
@@ -231,6 +232,18 @@ def _publish_subagent_event(
         pass
 
 
+#: 用量收集袋（6.45，DeepTalk design/170 §5）：子 agent 跑在父 agent 的工具调用里，它的用量原来只算它自己的——workflow 叶子派的
+#: 子 agent 花的 token 不进叶子的用量、不扣共享预算。每次 run_agent_spec 给子 agent 开一个新袋子；它下面再派的子 agent 跑完把
+#: 「自己 + 袋子里的」放进这个袋子；它自己跑完返回的 usage 也是「自己 + 袋子」，再放进上一层的袋子。
+_USAGE_SINK: ContextVar[dict[str, int] | None] = ContextVar("power_loop_usage_sink", default=None)
+
+
+def _add_usage(into: dict[str, int], usage: dict[str, Any] | None) -> None:
+    for k, v in (usage or {}).items():
+        if isinstance(v, (int, float)) and not isinstance(v, bool):
+            into[k] = int(into.get(k, 0)) + int(v)
+
+
 async def run_agent_spec(
     spec: AgentSpec | dict[str, Any] | str,
     user_input: str,
@@ -408,9 +421,20 @@ async def run_agent_spec(
         with contextlib.ExitStack() as _guard_stack:
             for _gname, _guard in getattr(parent_loop, "_child_run_guards", ()) or ():
                 _guard_stack.enter_context(_guard())
-            result = await child_loop.send(
-                user_input, session_id=child_sid, stop_event=stop_event
-            )
+            _outer_sink = _USAGE_SINK.get()
+            _my_sink: dict[str, int] = {}
+            _sink_tok = _USAGE_SINK.set(_my_sink)
+            try:
+                result = await child_loop.send(
+                    user_input, session_id=child_sid, stop_event=stop_event
+                )
+            finally:
+                _USAGE_SINK.reset(_sink_tok)
+            _total_usage: dict[str, int] = {}
+            _add_usage(_total_usage, dict(result.usage or {}))
+            _add_usage(_total_usage, _my_sink)
+            if _outer_sink is not None:
+                _add_usage(_outer_sink, _total_usage)
     except BaseException:
         # A raised child run (cancellation, provider error, bug) would otherwise leak the EPHEMERAL
         # child session — the cleanup below is only reached on a normal return (subagent-coordination-2).
@@ -474,5 +498,6 @@ async def run_agent_spec(
         "final_text": result.final_text,
         "rounds": result.rounds,
         "depth": depth,
-        "usage": dict(result.usage or {}),
+        # 自己 + 它下面所有子 agent 的用量（_USAGE_SINK）
+        "usage": _total_usage,
     }

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/tools/default_manifest.py

@@ -352,7 +352,7 @@ DEFAULT_TOOL_DEFINITIONS: list[ToolDefinition] = [
     ToolDefinition(
         name="background_run",
         description=(
-            "Manage private background tasks with one action: run, tool, or check. action=run "
+            "Manage private background tasks with one action: run, tool, check, list or wait. action=run "
             "starts a shell command in a private non-interactive background worker and returns its "
             "task_id immediately. action=tool runs one async-capable TOOL in the background "
             "(tool=<name>, args={…}) and returns a task_id at once — use it for long, "
@@ -362,7 +362,10 @@ DEFAULT_TOOL_DEFINITIONS: list[ToolDefinition] = [
             "While a task runs, do other work, or pass_turn if there is nothing else to do. "
             "action=check is a fallback: call it only when a wake message explicitly asks you to, "
             "or when you suspect a task is stuck — checking early just returns \"running\". It reports "
-            "status/output by task_id; action=list lists all your tasks."
+            "status/output by task_id; action=list lists all your tasks. action=wait blocks until the "
+            "given task_ids (or all your running tasks) finish and returns their results — use it when "
+            "you cannot be woken later (e.g. inside a workflow node) or when your next step needs those "
+            "results; a new message cuts the wait short."
         ),
         input_schema={
             "type": "object",
@@ -372,13 +375,15 @@ DEFAULT_TOOL_DEFINITIONS: list[ToolDefinition] = [
                     # list = check 不带 task_id 的显式别名（6.17.0）。原来「列出全部」这件事
                     # 藏在「check 不带参数」这个隐式约定里，模型要先知道才用得上——同一件事
                     # 该只有一个名字（design/96 §6.4）。
-                    "enum": ["run", "tool", "check", "list"],
+                    "enum": ["run", "tool", "check", "list", "wait"],
                     "description": "Operation to perform.",
                 },
                 "command": {"type": "string", "description": "Required for action=run: shell command to execute."},
                 "tool": {"type": "string", "description": "Required for action=tool: name of an async-capable tool (marked in its description)."},
                 "args": {"type": "object", "description": "action=tool: the tool's arguments, exactly as you would pass them when calling it directly."},
                 "task_id": {"type": "string", "description": "For action=check: task to inspect; omit to list all tasks."},
+                "task_ids": {"type": "array", "items": {"type": "string"}, "description": "For action=wait: tasks to wait for; omit to wait for all your running tasks."},
+                "timeout_s": {"type": "number", "description": "For action=wait: give up waiting after this many seconds (default 600, max 3600); tasks keep running."},
             },
             "required": ["action"],
         },

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/tools/default_tools.py

@@ -1571,8 +1571,11 @@ class BackgroundManager:
                     _a = async_capable_actions(_d)
                     _others.append(f"{_d.name}({'/'.join(_a)})" if _a else _d.name)
             raise ValueError(
-                f"{name} 不能后台跑：它有副作用（写文件 / 发布 / 对外投递这类），"
-                "重跑或并发都不安全。**这件事直接调用 " + name + " 就行**，不用包一层。"
+                # 只说事实：工具定义没声明 async_capable。没声明的一律按可能有副作用处理，但别断言它「有副作用」——
+                # 新工具的作者只是漏标时，那句话会被当成判断（10-16 建造师 world_sketch 事故）。
+                f"{name} 不能后台跑：这个工具没有声明可以后台跑（定义里没标 async_capable），"
+                "没声明的一律按可能有副作用（写文件 / 发布 / 对外投递这类）处理，重跑或并发不一定安全。"
+                "**这件事直接调用 " + name + " 就行**，不用包一层。"
                 + ("\n可以后台跑的是：" + "、".join(_others) if _others else "")
             )
         store, sid = _current_store_and_session()
@@ -1759,6 +1762,61 @@ class BackgroundManager:
         await asyncio.wait({worker}, timeout=5)
         return "forced"
 
+    async def _status_of(self, store: Any, sid: str | None, task_id: str) -> tuple[str, str]:
+        """(status, 输出尾巴)：优先读 store 里这个会话的行，没有就读进程内记录。"""
+        if store is not None and sid is not None:
+            row = await store.get_background_task(sid, task_id)
+            if row is not None:
+                return str(row.status), str(row.output_tail or "")
+        with self._lock:
+            task = self.tasks.get(task_id)
+        if task is None:
+            return "unknown", ""
+        return str(task.get("status") or "running"), str(task.get("result") or "")
+
+    async def wait(self, task_ids: list[str] | None = None, timeout_s: float = 600.0) -> str:
+        """等后台任务落定（6.45，DeepTalk design/170 §4）：workflow 的叶子收不到后台任务的完成唤醒——它要在自己这一轮里
+        等结果。不给 ``task_ids`` 就等本会话所有还在跑的。等的时候一条插话进来就提前返回（下一轮先处理插话）。
+        返回逐件状态和输出尾巴；超时只是不再等，任务照常在跑。"""
+        store, sid = _current_store_and_session()
+        if store is not None and sid is not None:
+            await self.flush_orphaned(store, sid)
+        ids = [str(x) for x in (task_ids or []) if str(x).strip()]
+        if not ids:
+            if store is not None and sid is not None:
+                ids = [r.task_id for r in await store.list_background_tasks(sid) if str(r.status) == "running"]
+            else:
+                with self._lock:
+                    ids = [tid for tid, tk in self.tasks.items() if tk.get("status") == "running"]
+        if not ids:
+            return "没有在跑的后台任务。"
+        timeout_s = max(1.0, min(float(timeout_s or 600.0), 3600.0))
+
+        async def _poll() -> None:
+            loop = asyncio.get_running_loop()
+            end = loop.time() + timeout_s
+            while loop.time() < end:
+                states = [(await self._status_of(store, sid, tid))[0] for tid in ids]
+                if all(s not in ("running", "unknown") for s in states):
+                    return
+                futs = {self._workers[tid] for tid in ids if tid in self._workers and not self._workers[tid].done()}
+                await asyncio.wait(futs or {asyncio.ensure_future(asyncio.sleep(1.0))}, timeout=1.0,
+                                   return_when=asyncio.FIRST_COMPLETED)
+
+        from power_loop.runtime.steer import wait_or_steer
+
+        _r, steered = await wait_or_steer(_poll(), session_id=sid)
+        lines = []
+        pending = 0
+        for tid in ids:
+            status, tail = await self._status_of(store, sid, tid)
+            pending += status == "running"
+            lines.append(f"{tid}: [{status}] {tail[-1500:] if tail else ''}".rstrip())
+        head = ("等的时候来了新消息，先停下来等（任务照常在跑）。" if steered
+                else f"还有 {pending} 件没做完（等了 {int(timeout_s)} 秒，任务照常在跑）。" if pending
+                else "都做完了。")
+        return head + "\n" + "\n".join(lines)
+
     async def check(self, task_id: str | None = None) -> str:
         store, sid = _current_store_and_session()
         if store is not None and sid is not None:
@@ -1814,6 +1872,7 @@ def register_tool_task_callback(cb: Any) -> None:
 async def run_background(
     action: str, command: str | None = None, task_id: str | None = None,
     tool: str | None = None, args: dict[str, Any] | None = None,
+    task_ids: list[str] | None = None, timeout_s: float | None = None,
 ) -> str:
     """Execute one action of the merged ``background_run`` tool."""
     operation = str(action or "").strip().lower()
@@ -1829,7 +1888,10 @@ async def run_background(
         return await BG.check(None)
     if operation == "tool":
         return await BG.run_tool(tool, args)
-    raise ValueError("background_run action must be one of: run, check, list, tool")
+    if operation == "wait":
+        ids = list(task_ids or []) or ([task_id] if task_id else [])
+        return await BG.wait(ids, timeout_s if timeout_s is not None else 600.0)
+    raise ValueError("background_run action must be one of: run, check, list, tool, wait")
 
 
 async def run_todo(items: list[dict[str, Any]]) -> str:
@@ -2338,7 +2400,7 @@ async def _h_recall_send(**kw: Any) -> Any:
 
 async def _h_background_run(**kw: Any) -> Any:
     return await run_background(kw["action"], kw.get("command"), kw.get("task_id"),
-                                kw.get("tool"), kw.get("args"))
+                                kw.get("tool"), kw.get("args"), kw.get("task_ids"), kw.get("timeout_s"))
 
 
 DEFAULT_TOOL_HANDLERS: dict[str, Any] = {

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/workflow/engine.py

@@ -28,6 +28,7 @@ driver session id **inside each leaf coroutine**, so concurrent fan-out tasks
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
 import re
 from collections.abc import Awaitable, Callable
@@ -62,7 +63,9 @@ logger = logging.getLogger(__name__)
 #: programmatically-built spec that bypasses the static validation caps. Fail-closed when exceeded.
 MAX_TOTAL_LEAVES = 10_000
 
-_VAR_RE = re.compile(r"\{\{\s*([a-zA-Z_]\w*)\s*\}\}")
+#: ``{{var}}``（foreach 变量等）和 ``{{node.key}}``（上游节点结构化输出里的一个键，6.45：之前不认带点的名字，
+#: YAML 的 ``${{ needs.x.outputs.k }}`` 编成 ``{{x.k}}`` 后原样送给了模型）。节点 id 可以带短横线。
+_VAR_RE = re.compile(r"\{\{\s*([a-zA-Z_][\w-]*(?:\.[a-zA-Z_]\w*)?)\s*\}\}")
 
 # Set while a workflow run is in flight. Propagates into child sub-agent tasks
 # (asyncio copies the context), so a leaf that calls the create_workflow tool can
@@ -150,19 +153,28 @@ class InProcessExecutor:
         ContinuationPolicy）钳制。"""
         import contextlib as _ctxlib
 
-        with _ctxlib.ExitStack() as guards:
-            for _name, guard in getattr(parent_loop, "_child_run_guards", ()) or ():
-                guards.enter_context(guard())
-            res = await parent_loop.follow_up(
-                user_input, session_id=session_id,
-                stop_event=stop_event, max_rounds=extra_rounds,
-            )
+        from power_loop.runtime.spec import _USAGE_SINK, _add_usage
+
+        sink: dict[str, int] = {}   # 续跑这几轮里派的子 agent 的用量也算进来（design/170 §5）
+        sink_tok = _USAGE_SINK.set(sink)
+        try:
+            with _ctxlib.ExitStack() as guards:
+                for _name, guard in getattr(parent_loop, "_child_run_guards", ()) or ():
+                    guards.enter_context(guard())
+                res = await parent_loop.follow_up(
+                    user_input, session_id=session_id,
+                    stop_event=stop_event, max_rounds=extra_rounds,
+                )
+        finally:
+            _USAGE_SINK.reset(sink_tok)
         status = str(getattr(res, "status", "failed") or "failed")
+        usage = await _usage_delta(parent_loop, session_id, getattr(res, "usage", None))
+        _add_usage(usage, sink)
         return {
             "status": status,
             "final_text": str(getattr(res, "final_text", "") or ""),
             "rounds": int(getattr(res, "rounds", 0) or 0),
-            "usage": await _usage_delta(parent_loop, session_id, getattr(res, "usage", None)),
+            "usage": usage,
             "session_id": session_id,
         }
 
@@ -369,6 +381,7 @@ class WorkflowEngine:
             final=self._last,
             usage=self._total_usage(),
             errors=list(self._errors),
+            tolerated=sorted(self._tolerated),
         )
 
     # ── node dispatch ──────────────────────────────────────────────────────
@@ -421,7 +434,7 @@ class WorkflowEngine:
             return res
         self._leaves_run += 1
 
-        user_input = _render(node.input, env)
+        user_input = _render(node.input, env, self._resolve_ref_soft)
         if node.inputs_from:
             extras = []
             for ref in node.inputs_from:
@@ -869,6 +882,16 @@ class WorkflowEngine:
             )
         return res.payload[key]
 
+    def _resolve_ref_soft(self, ref: str) -> str:
+        """渲染节点输入里的 ``{{node.key}}``：取不到时给一句明确说明，不让整个 run 崩（下游自己判断怎么办）。"""
+        try:
+            value = self._resolve_ref(ref)
+        except WorkflowRunError as exc:
+            return f"[取不到 {ref}：{exc}]"
+        if isinstance(value, (dict, list)):
+            return json.dumps(value, ensure_ascii=False)
+        return str(value)
+
     def _total_usage(self) -> dict[str, int]:
         # Accumulated once per real leaf / replayed result — not summed from
         # _results (where foreach bodies share one id and would mis-count).
@@ -883,11 +906,15 @@ def _sum_usage(results: list[AgentResult]) -> dict[str, int]:
     return total
 
 
-def _render(template: str, env: dict[str, Any]) -> str:
-    """Substitute ``{{var}}`` from ``env``; leave unknown placeholders untouched."""
+def _render(template: str, env: dict[str, Any], resolve_ref: Callable[[str], str] | None = None) -> str:
+    """Substitute ``{{var}}`` from ``env`` and ``{{node.key}}`` via ``resolve_ref``; leave unknown placeholders untouched."""
 
     def repl(m: re.Match[str]) -> str:
         name = m.group(1)
-        return str(env[name]) if name in env else m.group(0)
+        if name in env:
+            return str(env[name])
+        if "." in name and resolve_ref is not None:
+            return resolve_ref(name)
+        return m.group(0)
 
     return _VAR_RE.sub(repl, template)

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/workflow/result.py

@@ -69,6 +69,9 @@ class WorkflowResult:
     final: AgentResult | None = None
     usage: dict[str, int] = field(default_factory=dict)
     errors: list[str] = field(default_factory=list)
+    #: 失败但明确放行（continue_on_error）的节点 id（6.45）：宿主自己再判一遍 run 终态时要跳过它们，
+    #: 否则 continue_on_error 在宿主侧等于没开（DeepTalk design/170 §6）。
+    tolerated: list[str] = field(default_factory=list)
 
     @property
     def ok(self) -> bool:
@@ -98,6 +101,7 @@ class WorkflowResult:
             "final": self.final.to_dict() if self.final else None,
             "usage": self.usage,
             "errors": self.errors,
+            "tolerated": self.tolerated,
         }
 
 

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop/workflow/spec.py

@@ -45,7 +45,7 @@ from typing import Any
 from power_loop.contracts.errors import SpecValidationError
 from power_loop.runtime.spec import AgentSpec, AgentSpecError
 
-# Template variable identifier grammar — must match engine._VAR_RE's capture (`[a-zA-Z_]\w*`), so a
+# Template variable identifier grammar — a subset of engine._VAR_RE's capture (which also allows {{node.key}}), so a
 # foreach `as` name validated here is guaranteed substitutable as {{name}} in the body.
 _IDENTIFIER_RE = re.compile(r"^[A-Za-z_]\w*$")
 

{power_loop-6.44.0 → power_loop-6.45.0}/power_loop.egg-info/PKG-INFO

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