power-loop 5.3.0__tar.gz → 5.4.0__tar.gz

{power_loop-5.3.0 → power_loop-5.4.0}/PKG-INFO

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

{power_loop-5.3.0 → power_loop-5.4.0}/power_loop/__init__.py

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

@@ -274,10 +274,10 @@ class ProjectedRepresentation:
         # Tool results keyed by tool_call_id, preserving ORDER and DUPLICATES (a multimap of FIFO
         # queues): a malformed/imported/resumed transcript can repeat or omit an id, so a plain
         # dict would silently collapse two results onto one id (and drop the other).
-        results: dict[str, deque[str | None]] = {}
+        results: dict[str, deque[tuple[str | None, int | None]]] = {}
         for r in send_rows:
             if r.role == "tool":
-                results.setdefault(r.tool_call_id or "", deque()).append(r.content)
+                results.setdefault(r.tool_call_id or "", deque()).append((r.content, r.seq))
         tools: list[dict[str, Any]] = []
         inputs: list[str | None] = []
         final_text: str | None = None
@@ -293,7 +293,7 @@ class ProjectedRepresentation:
             if r.role == "user":
                 if seen_assistant:
                     # Verbatim like the input (conversation content, not tool output).
-                    tools.append({"name": "__user__", "text": r.content})
+                    tools.append({"name": "__user__", "text": r.content, "seq": r.seq})
                 else:
                     inputs.append(r.content)
                 continue
@@ -308,8 +308,17 @@ class ProjectedRepresentation:
                 name = fn.get("name") or tc.get("name")
                 args = _parse_args(fn.get("arguments"))
                 bucket = results.get(str(tc.get("id") or ""))
-                result = bucket.popleft() if bucket else _NO_RESULT
-                tools.append(self._project_tool(name, args, result, tool_registry))
+                result, result_seq = bucket.popleft() if bucket else (_NO_RESULT, None)
+                entry = self._project_tool(name, args, result, tool_registry)
+                # Row coordinates (5.4.0): every projected tool entry carries the pl_messages seq of
+                # its RESULT row (``seq``) and of the assistant row that issued the call
+                # (``call_seq``), so a host renderer can print a self-contained
+                # "recall_send(send_index=N, seq=S)" pointer on each line — the model should never
+                # have to scan other sends to find where a dropped body lives.
+                if isinstance(entry, dict):
+                    entry.setdefault("seq", result_seq)
+                    entry.setdefault("call_seq", r.seq)
+                tools.append(entry)
         seqs = [r.seq for r in send_rows]
         rows: list[ProjectedRow] = []
         if inputs:
@@ -462,7 +471,9 @@ class ProjectedRepresentation:
             # A mid-send user injection (reminder / finalize / steering) at its
             # chronological position in the timeline — not a tool call.
             return f"[user] {t.get('text') or ''}"
-        rest = {k: v for k, v in (t or {}).items() if k != "name"}
+        # Row coordinates (seq / call_seq, 5.4.0) are bookkeeping for host renderers, not part of
+        # the generic "name(k=v, …)" line — a host that wants a recall pointer overrides the render.
+        rest = {k: v for k, v in (t or {}).items() if k not in ("name", "seq", "call_seq")}
         if not rest:
             return str(name)
         body = self.render_config.tool_arg_sep.join(f"{k}={v}" for k, v in rest.items())

{power_loop-5.3.0 → power_loop-5.4.0}/power_loop/tools/default_manifest.py

@@ -277,15 +277,18 @@ DEFAULT_TOOL_DEFINITIONS: list[ToolDefinition] = [
     ToolDefinition(
         name="recall_send",
         description=(
-            "Re-expand an earlier send shown in your context only as a compact summary. When you "
-            "need the EXACT original detail of a specific past send — its tool calls, their "
-            "results, files touched, full text — call this with that send's index (the #N shown "
-            "in the summary). Read-only, current session."
+            "Re-expand an earlier send shown in your context only as a compact summary. Each "
+            "summarized tool line carries a coordinate «#N·sS» (send_index N, row seq S). To get "
+            "ONE original tool result in full (a file you read, a skill you loaded, a vision answer, "
+            "a command's output), call recall_send(send_index=N, seq=S) — that returns just that row "
+            "with a large cap. Without seq it lists every row of send #N (each body cut at 2000 "
+            "chars) — use that only to see what happened, not to fetch a body. Read-only, current session."
         ),
         input_schema={
             "type": "object",
             "properties": {
-                "send_index": {"type": "integer", "description": "The #N of the past send to expand."},
+                "send_index": {"type": "integer", "description": "The #N of the past send."},
+                "seq": {"type": "integer", "description": "Optional: the sS row coordinate from a summary line → return that single row in full."},
             },
             "required": ["send_index"],
         },

{power_loop-5.3.0 → power_loop-5.4.0}/power_loop/tools/default_tools.py

@@ -1696,16 +1696,21 @@ async def run_recall_compacted(
 # ── recall_send: re-expand a send the projection layer summarized ──────────────
 
 RECALL_SEND_CONTENT_CHARS = 2000
+# Single-row recall (``recall_send(send_index, seq=…)``) returns the ORIGINAL body — a skill file,
+# a read file, a vision answer — so its cap is generous. The send-level view keeps the small cap
+# because it lists every row of the send.
+RECALL_SEND_ROW_CHARS = 40_000
 
 
-async def run_recall_send(send_index: int) -> str:
+async def run_recall_send(send_index: int, seq: int | None = None) -> str:
     """Re-expand one past send the send-context projection summarized.
 
     When ``AgentLoopConfig.history_projector`` is set, finished sends appear in context as a
     compact projected summary while their FULL detail stays in ``pl_messages`` (the immutable
     audit). This returns that send's original messages — assistant text, tool calls (by name)
     and their results — read-only, current session, by the ``send_index`` (the ``#N`` the
-    summary shows).
+    summary shows). With ``seq`` it returns just THAT row (the ``sS`` coordinate a projected
+    tool line carries) with a much larger body cap — plus the assistant call that produced it.
     """
     ctx = get_tool_runtime_context(required=True)
     store, sid = ctx.store, ctx.session_id
@@ -1720,6 +1725,18 @@ async def run_recall_send(send_index: int) -> str:
     if not rows:
         return f"No messages found for send #{target} in this session."
 
+    if seq is not None:
+        try:
+            want = int(seq)
+        except (TypeError, ValueError):
+            return f"Invalid seq: {seq!r} (expected an integer)."
+        hit = next((r for r in rows if r.seq == want), None)
+        if hit is None:
+            lo, hi = min(r.seq for r in rows), max(r.seq for r in rows)
+            return (f"No row seq {want} in send #{target} (its rows span seq {lo}–{hi}). "
+                    "Use the exact «sS» coordinate from the summary line, or omit seq to list the whole send.")
+        return _render_recall_row(hit, rows, cap=RECALL_SEND_ROW_CHARS, head=f"send #{target} · seq {want}")
+
     def _tc_name(tc: dict[str, Any]) -> str:
         # ``function`` is normally a dict, but a malformed/imported tool_call can carry a
         # non-dict (e.g. a bare string); guard so name extraction never raises (the tool
@@ -1752,6 +1769,30 @@ async def run_recall_send(send_index: int) -> str:
     return f"send #{target} — {len(rows)} message(s):\n\n" + "\n\n".join(blocks)
 
 
+def _render_recall_row(hit: Any, rows: list[Any], *, cap: int, head: str) -> str:
+    """One original row in full (capped at ``cap`` chars, remainder counted), preceded by the
+    assistant call that produced it when the row is a tool result."""
+    blocks: list[str] = []
+    if hit.role == "tool" and hit.tool_call_id:
+        for a in rows:
+            for tc in (a.tool_calls or []) if a.role == "assistant" else []:
+                if str(tc.get("id") or "") == str(hit.tool_call_id):
+                    fn = tc.get("function")
+                    fn = fn if isinstance(fn, dict) else {}
+                    blocks.append(
+                        f"[seq {a.seq} · assistant call · {fn.get('name') or tc.get('name') or '?'}]\n"
+                        f"{fn.get('arguments') or ''}"
+                    )
+                    break
+    body = hit.content or ""
+    total = len(body)
+    if total > cap:
+        body = body[:cap] + f" …[truncated: {total - cap} more chars of {total}]"
+    label = f"[seq {hit.seq} · {hit.role}" + (f" · {hit.name}" if hit.name else "") + "]"
+    blocks.append(f"{label}\n{body}")
+    return f"{head} — original row ({total} chars):\n\n" + "\n\n".join(blocks)
+
+
 # Async tool handlers are registered as ``async def`` adapters (NOT sync lambdas that
 # merely return a coroutine): the registry uses ``inspect.iscoroutinefunction`` to decide
 # sync-vs-async dispatch and to keep the per-call ``runtime_env_context`` held across the
@@ -1783,7 +1824,7 @@ async def _h_recall_compacted(**kw: Any) -> Any:
 
 
 async def _h_recall_send(**kw: Any) -> Any:
-    return await run_recall_send(kw["send_index"])
+    return await run_recall_send(kw["send_index"], kw.get("seq"))
 
 
 async def _h_background_run(**kw: Any) -> Any:

{power_loop-5.3.0 → power_loop-5.4.0}/power_loop.egg-info/PKG-INFO

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