power-loop 3.8.1__tar.gz → 3.10.0__tar.gz

{power_loop-3.8.1 → power_loop-3.10.0}/PKG-INFO

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

{power_loop-3.8.1 → power_loop-3.10.0}/power_loop/__init__.py

@@ -15,7 +15,7 @@ Stability tiers
 无版本承诺，可随时变更或删除。
 """
 
-__version__ = "3.8.1"
+__version__ = "3.10.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-3.8.1 → power_loop-3.10.0}/power_loop/agent/stateful_loop.py

@@ -559,6 +559,7 @@ class StatefulAgentLoop:
         tools: Sequence[str] | ToolRegistry | None = None,
         system_prompt: str | None = None,
         heal_pending: bool = False,
+        max_rounds: int | None = None,
     ) -> StatefulResult:
         """Append one user input to the session and run the loop.
 
@@ -596,7 +597,8 @@ class StatefulAgentLoop:
                 await self._raise_if_pending(sid)
             await self._persist_user_input(sid, user_input)
             return await self._run_loop(
-                sid, stop_event=stop_event, tools=tools, system_prompt=system_prompt
+                sid, stop_event=stop_event, tools=tools, system_prompt=system_prompt,
+                max_rounds=max_rounds,
             )
 
     async def follow_up(
@@ -607,6 +609,7 @@ class StatefulAgentLoop:
         stop_event: CancellationLike = None,
         tools: Sequence[str] | ToolRegistry | None = None,
         system_prompt: str | None = None,
+        max_rounds: int | None = None,
     ) -> StatefulResult | FollowUpQueued:
         """Steer an in-flight loop, or fall back to :meth:`send`.
 
@@ -617,6 +620,10 @@ class StatefulAgentLoop:
         clears the drained items.
 
         When the session is idle (lock not held), behaves like :meth:`send`.
+
+        ``max_rounds`` (per-call, idle path only): run this continuation with a different round
+        budget than ``config.max_rounds`` — e.g. a short bounded "finalize" turn. Ignored on the
+        STEERED path (an in-flight loop's own budget governs the drained follow-up).
         """
         sid = session_id
         self._raise_if_closing()
@@ -627,7 +634,8 @@ class StatefulAgentLoop:
             depth = await self._enqueue_follow_up(sid, user_input)
             return FollowUpQueued(session_id=sid, queue_depth=depth)
         return await self.send(
-            user_input, sid, stop_event=stop_event, tools=tools, system_prompt=system_prompt
+            user_input, sid, stop_event=stop_event, tools=tools, system_prompt=system_prompt,
+            max_rounds=max_rounds,
         )
 
     def _run_sync(self, coro: Coroutine[Any, Any, Any]) -> Any:
@@ -1202,6 +1210,7 @@ class StatefulAgentLoop:
         sink: SQLiteSink | None = None,
         tools: Sequence[str] | ToolRegistry | None = None,
         system_prompt: str | None = None,
+        max_rounds: int | None = None,
     ) -> StatefulResult:
         store = await self._ensure_store()
         # 3.0: projection-style representation drives the derived-layer path; verbatim → None
@@ -1442,9 +1451,14 @@ class StatefulAgentLoop:
         effective_sp = system_prompt
         if effective_sp is None and session_row is not None and session_row.system_prompt:
             effective_sp = session_row.system_prompt
-        runtime_config = self.config
+        # Per-call config overrides (system_prompt, max_rounds) → a per-run copy; never mutate
+        # self.config (shared across concurrent sessions).
+        _overrides: dict[str, Any] = {}
         if effective_sp is not None and effective_sp != self.config.system_prompt:
-            runtime_config = replace(self.config, system_prompt=effective_sp)
+            _overrides["system_prompt"] = effective_sp
+        if max_rounds is not None and int(max_rounds) != self.config.max_rounds:
+            _overrides["max_rounds"] = max(1, int(max_rounds))
+        runtime_config = replace(self.config, **_overrides) if _overrides else self.config
         effective_registry = self._resolve_registry(tools)
 
         async with self._runner.session_async(session_id=sid):

{power_loop-3.8.1 → power_loop-3.10.0}/power_loop/contracts/hook_contexts.py

@@ -125,6 +125,13 @@ class LlmBeforeCtx(BaseHookCtx):
     Handler may modify any input field. ``messages`` is the fresh per-call list
     actually sent to the LLM — mutating it (e.g. appending an ephemeral memory
     block) never touches the loop's persisted history.
+
+    ``persist_messages`` is the durable counterpart: any message a handler appends
+    here becomes a REAL history/store row (stamped with the round's send_index, via
+    the same append path as the loop's own turns) AND is added to this round's
+    request. Use it for injected turns that must survive the send — e.g. a periodic
+    "you haven't called X in N rounds" reminder — as opposed to the ephemeral,
+    request-only edits to ``messages``. Appended in order, at the tail of the request.
     """
 
     messages: list[LoopMessage] = field(default_factory=list)
@@ -133,6 +140,8 @@ class LlmBeforeCtx(BaseHookCtx):
     max_tokens: int = 8000
     temperature: float = 0.0
     session_id: str | None = None
+    # Durable injections: persisted as real turns after LLM_BEFORE, then added to the request.
+    persist_messages: list[LoopMessage] = field(default_factory=list)
     # Handler output (for SHORT_CIRCUIT)
     output: LLMResponse | None = None
 

{power_loop-3.8.1 → power_loop-3.10.0}/power_loop/core/pipeline.py

@@ -944,6 +944,16 @@ class AgentPipeline:
                 llm_before.messages, _pre_hook_ids, _hook_audit_mode
             )
 
+            # Durable LLM_BEFORE injections (persist_messages): unlike the ephemeral, request-only
+            # edits to `messages` (captured by hook_audit above), each of these becomes a REAL turn —
+            # persisted to history + store with the round's send_index via the loop's own append path
+            # — and is added to this round's request tail. Used for injected turns that must survive
+            # the send (e.g. a periodic "you haven't called X in N rounds" reminder). Computed AFTER
+            # hook_audit so these durable rows don't get counted as ephemeral injections.
+            for _pm in llm_before.persist_messages:
+                await self._append_message(_pm, round_index=round_idx)
+                llm_before.messages.append(dict(_pm))
+
             if llm_before.directive == HookDirective.SHORT_CIRCUIT:
                 response = llm_before.output
                 if not isinstance(response, LLMResponse):

{power_loop-3.8.1 → power_loop-3.10.0}/power_loop.egg-info/PKG-INFO

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