AbstractAgent 0.3.16__tar.gz → 0.3.18__tar.gz

{abstractagent-0.3.16/src/abstractagent.egg-info → abstractagent-0.3.18}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.16
+Version: 0.3.18
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: abstractcore[tools]>=2.13.41
-Requires-Dist: abstractruntime>=0.5.0
+Requires-Dist: abstractcore[tools]>=2.25.0
+Requires-Dist: abstractruntime>=0.7.0
 Provides-Extra: apple
-Requires-Dist: abstractcore[all-apple]>=2.13.41; extra == "apple"
-Requires-Dist: abstractruntime[apple]>=0.5.0; extra == "apple"
+Requires-Dist: abstractcore[all-apple]>=2.25.0; extra == "apple"
+Requires-Dist: abstractruntime[apple]>=0.7.0; extra == "apple"
 Provides-Extra: gpu
-Requires-Dist: abstractcore[all-gpu]>=2.13.41; extra == "gpu"
-Requires-Dist: abstractruntime[gpu]>=0.5.0; extra == "gpu"
+Requires-Dist: abstractcore[all-gpu]>=2.25.0; extra == "gpu"
+Requires-Dist: abstractruntime[gpu]>=0.7.0; extra == "gpu"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: test
@@ -105,10 +105,13 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-AbstractAgent 0.3.16 requires `abstractcore[tools]>=2.13.41` and
-`AbstractRuntime>=0.5.0` (the runtime release that provides live token
-streaming, on top of turn grounding, in-flight cancellation and speculation
-inheritance). AbstractRuntime 0.5.0 itself requires AbstractCore 2.16.0 or newer.
+AbstractAgent 0.3.17 requires `abstractcore[tools]>=2.13.41` and
+`AbstractRuntime>=0.7.0` (the runtime release with the 50k-token history
+window, which ReAct applies to its requests when a host sets
+`_runtime.history_window_tokens`, as the entity visit does; 0.5.0 brought live
+token streaming, on top of turn grounding, in-flight cancellation and
+speculation inheritance). AbstractRuntime 0.7.0 itself requires AbstractCore
+2.18.0 or newer.
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

{abstractagent-0.3.16 → abstractagent-0.3.18}/README.md

@@ -84,10 +84,13 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-AbstractAgent 0.3.16 requires `abstractcore[tools]>=2.13.41` and
-`AbstractRuntime>=0.5.0` (the runtime release that provides live token
-streaming, on top of turn grounding, in-flight cancellation and speculation
-inheritance). AbstractRuntime 0.5.0 itself requires AbstractCore 2.16.0 or newer.
+AbstractAgent 0.3.17 requires `abstractcore[tools]>=2.13.41` and
+`AbstractRuntime>=0.7.0` (the runtime release with the 50k-token history
+window, which ReAct applies to its requests when a host sets
+`_runtime.history_window_tokens`, as the entity visit does; 0.5.0 brought live
+token streaming, on top of turn grounding, in-flight cancellation and
+speculation inheritance). AbstractRuntime 0.7.0 itself requires AbstractCore
+2.18.0 or newer.
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

{abstractagent-0.3.16 → abstractagent-0.3.18}/pyproject.toml

@@ -4,23 +4,23 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "abstractagent"
-version = "0.3.16"
+version = "0.3.18"
 description = "Agent implementations using AbstractRuntime and AbstractCore"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "abstractcore[tools]>=2.13.41",
-    "abstractruntime>=0.5.0",
+    "abstractcore[tools]>=2.25.0",
+    "abstractruntime>=0.7.0",
 ]
 
 [project.optional-dependencies]
 apple = [
-    "abstractcore[all-apple]>=2.13.41",
-    "abstractruntime[apple]>=0.5.0",
+    "abstractcore[all-apple]>=2.25.0",
+    "abstractruntime[apple]>=0.7.0",
 ]
 gpu = [
-    "abstractcore[all-gpu]>=2.13.41",
-    "abstractruntime[gpu]>=0.5.0",
+    "abstractcore[all-gpu]>=2.25.0",
+    "abstractruntime[gpu]>=0.7.0",
 ]
 dev = [
     "pytest>=7.0",

{abstractagent-0.3.16 → abstractagent-0.3.18}/src/abstractagent/adapters/react_runtime.py

@@ -24,6 +24,7 @@ from typing import Any, Callable, Dict, List, Optional
 from abstractcore.tools import ToolCall
 from abstractruntime import Effect, EffectType, RunState, StepPlan, WorkflowSpec
 from abstractruntime.core.vars import ensure_limits, ensure_namespaces
+from abstractruntime.session_history import window_transcript
 from abstractruntime.turn_grounding import stamp_user_turn_grounding, strip_turn_grounding
 
 from .generation_params import (
@@ -1659,6 +1660,31 @@ def create_react_workflow(
                 out.append(d)
         return out
 
+    def _history_window_view(messages: List[Dict[str, Any]], runtime_ns: Any) -> List[Dict[str, Any]]:
+        """The transcript a model request carries when the host asks for THE
+        runtime history window (`_runtime.history_window_tokens`, set by the
+        entity visit's BRIDGE; operator ruling 2026-09-28, ADR-0026).
+
+        `abstractruntime.session_history.window_transcript`: the newest whole
+        turns up to that many tokens (a tool result stays with its turn), a
+        labeled #TRUNCATION notice when older turns were dropped. The turn in
+        progress starts at `_runtime.history_window_turn_start` (set by the
+        host) and is kept whole, so an ask_user answer or operator guidance
+        inside it never splits off the turn's own question and tool results. The durable
+        `context.messages` is never touched — only this request's view — and
+        the window's receipt is recorded at `_runtime.session_history`.
+        Unset = the whole transcript (the plain task lane's full-context policy).
+        """
+        if not isinstance(runtime_ns, dict) or runtime_ns.get("history_window_tokens") is None:
+            return messages
+        window = window_transcript(
+            messages,
+            max_tokens=runtime_ns["history_window_tokens"],
+            current_turn_start=runtime_ns.get("history_window_turn_start"),
+        )
+        runtime_ns["session_history"] = dict(window.report)
+        return list(window)
+
     def _sanitize_llm_messages(
         messages: Any, *, limits: Optional[Dict[str, Any]] = None
     ) -> List[Dict[str, Any]]:
@@ -1874,7 +1900,7 @@ def create_react_workflow(
 
 
         payload: Dict[str, Any] = {"prompt": ""}
-        sanitized_messages = _sanitize_llm_messages(messages_view, limits=limits)
+        sanitized_messages = _sanitize_llm_messages(_history_window_view(messages_view, runtime_ns), limits=limits)
         if sanitized_messages:
             payload["messages"] = sanitized_messages
         else:
@@ -3765,7 +3791,7 @@ def create_react_workflow(
             )
 
             payload: Dict[str, Any] = {"prompt": ""}
-            sanitized_messages = _sanitize_llm_messages(messages_view, limits=limits)
+            sanitized_messages = _sanitize_llm_messages(_history_window_view(messages_view, runtime_ns), limits=limits)
             if sanitized_messages:
                 payload["messages"] = sanitized_messages
             else:

{abstractagent-0.3.16 → abstractagent-0.3.18}/src/abstractagent/sandbox/local.py

@@ -11,7 +11,7 @@ import os
 import subprocess
 import sys
 import time
-from typing import Optional
+from typing import Any, Optional
 
 from .interface import ExecutionResult
 
@@ -22,9 +22,14 @@ class LocalSandbox:
         *,
         cwd: Optional[str] = None,
         python_executable: Optional[str] = None,
+        command_sandbox: Any = None,
     ):
+        """`command_sandbox`: an AbstractCore `abstractcore.tools.sandbox.Sandbox` (round 12). When
+        given, the interpreter runs inside it (OS sandbox bound to the run's workspaces, the host's
+        scrubbed environment, a private TMPDIR); the caller refuses before when it `refuses`."""
         self._cwd = cwd or os.getcwd()
         self._python = python_executable or sys.executable
+        self._command_sandbox = command_sandbox
 
     def reset(self) -> None:
         # Stateless sandbox (new subprocess per call).
@@ -47,10 +52,19 @@ class LocalSandbox:
             except (TypeError, ValueError):
                 t = 0.0
             eff_timeout = t if t > 0 else None
+        argv = [self._python, "-c", code]
+        env = None
+        box = self._command_sandbox
+        if box is not None:
+            if box.kind == "unsandboxed":
+                env = box.env_for()
+            else:
+                argv, env = box.wrap(argv, self._cwd)
         try:
             completed = subprocess.run(
-                [self._python, "-c", code],
+                argv,
                 cwd=self._cwd,
+                env=env,
                 capture_output=True,
                 text=True,
                 timeout=eff_timeout,

{abstractagent-0.3.16 → abstractagent-0.3.18}/src/abstractagent/tools/code_execution.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from typing import Optional
+
 from abstractcore.tools import tool
 
 
@@ -25,16 +27,30 @@ def _bound_output(text: str, *, max_chars: int) -> str:
     )
 
 
+# Round 12: the one sentence when the installed AbstractCore has no command sandbox.
+NO_CORE_SANDBOX = (
+    "Commands are refused: the installed AbstractCore has no command sandbox "
+    "(abstractcore.tools.sandbox, AbstractCore 2.25.0 or newer)."
+)
+
+
 @tool(
     name="execute_python",
-    description="Execute a Python snippet in a subprocess sandbox. Returns stdout/stderr/exit_code in full.",
+    description="Execute a Python snippet in a subprocess, sandboxed to this run's workspaces. Returns stdout/stderr/exit_code in full.",
     when_to_use="When you need to compute, inspect files, or transform data using Python code",
+    # Stamped by the host (AbstractRuntime) with the run's workspace set; never model-facing.
+    hide_args=["_sandbox"],
 )
-def execute_python(code: str, timeout_s: float = 0.0, max_output_chars: int = 0) -> dict:
+def execute_python(code: str, timeout_s: float = 0.0, max_output_chars: int = 0, _sandbox: Optional[dict] = None) -> dict:
     """Execute Python code in a local subprocess.
 
     Notes:
-    - This is a dev sandbox. It is not a hardened security boundary.
+    - Round 12: when the host stamps `_sandbox` (the run's effective workspace set), the
+      interpreter runs inside AbstractCore's OS sandbox (macOS sandbox-exec, Linux bwrap/Landlock),
+      starting in the run's private workspace with the host's scrubbed environment. No sandbox
+      on the host (or an AbstractCore without one) = refused (`error` carries the sentence,
+      nothing runs). A host that configured AbstractCore's command policy refuses an unstamped
+      call. Library use without a host policy runs as before.
     - `timeout_s <= 0` (the default) means NO timeout (ADR-0027: no low default
       timeouts on correctness-critical paths — a 10s default silently killed
       legitimate long computations and reported them as errors). Pass a positive
@@ -48,7 +64,24 @@ def execute_python(code: str, timeout_s: float = 0.0, max_output_chars: int = 0)
 
     from ..sandbox.local import LocalSandbox
 
-    sandbox = LocalSandbox()
+    try:
+        from abstractcore.tools import sandbox as core_sandbox
+    except ImportError:
+        return {"stdout": "", "stderr": "", "exit_code": 126, "duration_ms": 0.0, "error": NO_CORE_SANDBOX, "success": False}
+    box = core_sandbox.sandbox_for_tool_call(_sandbox)
+    if box.refuses:
+        return {
+            "stdout": "",
+            "stderr": "",
+            "exit_code": 126,
+            "duration_ms": 0.0,
+            "error": box.refusal(),
+            "success": False,
+            "sandbox": box.describe(),
+            "sandbox_line": box.rendered_line(),
+        }
+    bound = box if (box.spec is not None or box.kind != core_sandbox.KIND_UNSANDBOXED) else None
+    sandbox = LocalSandbox(cwd=box.spec.private_workspace if box.spec is not None else None, command_sandbox=bound)
     #[WARNING:TIMEOUT] caller-supplied only; <= 0 = unlimited (ADR-0027)
     timeout = float(timeout_s)
     result = sandbox.execute(code, timeout_s=timeout if timeout > 0 else None)
@@ -56,11 +89,15 @@ def execute_python(code: str, timeout_s: float = 0.0, max_output_chars: int = 0)
         cap = int(max_output_chars)
     except (TypeError, ValueError):
         cap = 0
-    return {
+    out = {
         "stdout": _bound_output(result.stdout, max_chars=cap),
         "stderr": _bound_output(result.stderr, max_chars=cap),
         "exit_code": int(result.exit_code),
         "duration_ms": float(result.duration_ms),
         "error": result.error,
     }
+    if bound is not None:
+        out["sandbox"] = bound.describe()
+        out["sandbox_line"] = bound.rendered_line()
+    return out
 

{abstractagent-0.3.16 → abstractagent-0.3.18/src/abstractagent.egg-info}/PKG-INFO

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.16
+Version: 0.3.18
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: abstractcore[tools]>=2.13.41
-Requires-Dist: abstractruntime>=0.5.0
+Requires-Dist: abstractcore[tools]>=2.25.0
+Requires-Dist: abstractruntime>=0.7.0
 Provides-Extra: apple
-Requires-Dist: abstractcore[all-apple]>=2.13.41; extra == "apple"
-Requires-Dist: abstractruntime[apple]>=0.5.0; extra == "apple"
+Requires-Dist: abstractcore[all-apple]>=2.25.0; extra == "apple"
+Requires-Dist: abstractruntime[apple]>=0.7.0; extra == "apple"
 Provides-Extra: gpu
-Requires-Dist: abstractcore[all-gpu]>=2.13.41; extra == "gpu"
-Requires-Dist: abstractruntime[gpu]>=0.5.0; extra == "gpu"
+Requires-Dist: abstractcore[all-gpu]>=2.25.0; extra == "gpu"
+Requires-Dist: abstractruntime[gpu]>=0.7.0; extra == "gpu"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: test
@@ -105,10 +105,13 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-AbstractAgent 0.3.16 requires `abstractcore[tools]>=2.13.41` and
-`AbstractRuntime>=0.5.0` (the runtime release that provides live token
-streaming, on top of turn grounding, in-flight cancellation and speculation
-inheritance). AbstractRuntime 0.5.0 itself requires AbstractCore 2.16.0 or newer.
+AbstractAgent 0.3.17 requires `abstractcore[tools]>=2.13.41` and
+`AbstractRuntime>=0.7.0` (the runtime release with the 50k-token history
+window, which ReAct applies to its requests when a host sets
+`_runtime.history_window_tokens`, as the entity visit does; 0.5.0 brought live
+token streaming, on top of turn grounding, in-flight cancellation and
+speculation inheritance). AbstractRuntime 0.7.0 itself requires AbstractCore
+2.18.0 or newer.
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

{abstractagent-0.3.16 → abstractagent-0.3.18}/src/abstractagent.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ tests/test_codeact_logic.py
 tests/test_codeact_runtime_verifier_policy.py
 tests/test_delegate_session_route_composition.py
 tests/test_emit_inventory_drift.py
+tests/test_execute_python_sandbox.py
 tests/test_gated_remainder_wave_2026_07_14.py
 tests/test_generation_params_media_policies.py
 tests/test_history_monster_clamp.py
@@ -90,6 +91,7 @@ tests/test_react_delegate_agent_tool.py
 tests/test_react_election_fence_conformance.py
 tests/test_react_entity_dress_conformance.py
 tests/test_react_guidance_durable_transcript.py
+tests/test_react_history_window.py
 tests/test_react_logic.py
 tests/test_react_loop_aborted_generation_retry.py
 tests/test_react_loop_context_transcript_levels.py

abstractagent-0.3.18/src/abstractagent.egg-info/requires.txt

@@ -0,0 +1,16 @@
+abstractcore[tools]>=2.25.0
+abstractruntime>=0.7.0
+
+[apple]
+abstractcore[all-apple]>=2.25.0
+abstractruntime[apple]>=0.7.0
+
+[dev]
+pytest>=7.0
+
+[gpu]
+abstractcore[all-gpu]>=2.25.0
+abstractruntime[gpu]>=0.7.0
+
+[test]
+pytest>=7.0

abstractagent-0.3.18/tests/test_execute_python_sandbox.py

@@ -0,0 +1,121 @@
+"""Round 12: execute_python runs inside AbstractCore's OS command sandbox.
+
+Real macOS tests (sandbox-exec) with scratch folders and markers; the runtime path
+(AbstractRuntime stamps `_sandbox` on the CodeAct tool call) is exercised end to end."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+from abstractcore.tools import sandbox as core_sandbox
+from abstractcore.tools.sandbox import SandboxRow, SandboxSpec
+
+from abstractagent.tools.code_execution import NO_CORE_SANDBOX, execute_python
+
+MARK = "R12-AGENT-REFUSED-MARKER"
+
+macos_only = pytest.mark.skipif(
+    sys.platform != "darwin" or not os.access(core_sandbox.SANDBOX_EXEC, os.X_OK),
+    reason="real sandbox test: this host is not macOS with /usr/bin/sandbox-exec (Linux backends are tested in abstractcore)",
+)
+
+
+@pytest.fixture(autouse=True)
+def _fresh_host():
+    core_sandbox._reset_host_for_tests()
+    yield
+    core_sandbox._reset_host_for_tests()
+
+
+@pytest.fixture
+def t(tmp_path, monkeypatch):
+    root = Path(os.path.realpath(tmp_path))
+    for d in ("home", "priv", "refused", "rw"):
+        (root / d).mkdir()
+    (root / "refused/secret.txt").write_text(MARK)
+    monkeypatch.setenv("HOME", str(root / "home"))
+    return root
+
+
+def _stamp(t: Path, refused=True):
+    return SandboxSpec(
+        private_workspace=str(t / "priv"),
+        posture="any_except_denied",
+        allowed=(SandboxRow(str(t / "rw"), "rw"),),
+        refused=(str(t / "refused"),) if refused else (),
+    ).to_stamp()
+
+
+def test_sandbox_arg_is_hidden_from_the_model():
+    assert "_sandbox" not in execute_python._tool_definition.parameters
+
+
+@macos_only
+def test_refused_path_is_unreadable_from_python(t):
+    code = f"print(open({str(t / 'refused/secret.txt')!r}).read())"
+    res = execute_python(code, _sandbox=_stamp(t))
+    assert MARK not in res["stdout"] and res["exit_code"] != 0
+    assert "Operation not permitted" in res["stderr"]
+    assert res["sandbox"]["kind"] == "macos-sandbox-exec" and res["sandbox_line"] == "Sandbox: macOS sandbox-exec"
+    ok = execute_python(code, _sandbox=_stamp(t, refused=False))
+    assert MARK in ok["stdout"]  # positive control
+
+
+@macos_only
+def test_starts_in_the_private_workspace_with_a_private_tmpdir(t):
+    res = execute_python("import os,tempfile;open('w.txt','w').write('x');print(os.getcwd());print(tempfile.gettempdir())", _sandbox=_stamp(t))
+    assert res["stdout"].split() == [str(t / "priv"), str(t / "priv/.tmp")]
+    assert (t / "priv/w.txt").exists()
+
+
+def test_fail_closed_without_a_sandbox(t, monkeypatch):
+    monkeypatch.setattr(core_sandbox, "host_sandbox_kind", lambda posture="allowed_only": core_sandbox.KIND_NONE)
+    res = execute_python(f"open({str(t / 'priv/ran')!r},'w')", _sandbox=_stamp(t))
+    assert res["success"] is False and res["error"].startswith("Commands are not sandboxed on this gateway host")
+    assert not (t / "priv/ran").exists()
+
+
+def test_fail_closed_without_core_sandbox_module(t, monkeypatch):
+    import abstractcore.tools as core_tools
+
+    monkeypatch.setitem(sys.modules, "abstractcore.tools.sandbox", None)
+    monkeypatch.delattr(core_tools, "sandbox", raising=False)
+    res = execute_python(f"open({str(t / 'priv/ran')!r},'w')", _sandbox=_stamp(t))
+    assert res["success"] is False and res["error"] == NO_CORE_SANDBOX
+    assert not (t / "priv/ran").exists()
+
+
+def test_configured_host_refuses_unstamped_call(t):
+    core_sandbox.configure_host(env={"PATH": "/usr/bin:/bin"})
+    res = execute_python(f"open({str(t / 'priv/ran')!r},'w')")
+    assert res["success"] is False and res["error"] == core_sandbox.REFUSED_NO_SPEC
+    assert not (t / "priv/ran").exists()
+
+
+@macos_only
+def test_codeact_tool_call_through_the_runtime_is_sandboxed(t):
+    """A CodeAct-style TOOL_CALLS effect: the runtime stamps the run's workspaces on
+    execute_python; reading a refused workspace fails inside the sandbox."""
+    from abstractruntime.core.models import Effect, EffectType, RunState
+    from abstractruntime.integrations.abstractcore.effect_handlers import make_tool_calls_handler
+    from abstractruntime.integrations.abstractcore.tool_executor import MappingToolExecutor
+
+    handler = make_tool_calls_handler(tools=MappingToolExecutor.from_tools([execute_python]))
+    run_vars = {
+        "workspace_root": str(t / "priv"),
+        "workspace_access_mode": "all_except_ignored",
+        "workspace_allowed_paths": [str(t / "rw")],
+        "workspace_ignored_paths": str(t / "refused"),
+    }
+    run = RunState.new(workflow_id="wf", entry_node="n", session_id="s", vars=run_vars)
+    code = f"print(open({str(t / 'refused/secret.txt')!r}).read())"
+    effect = Effect(type=EffectType.TOOL_CALLS, payload={"tool_calls": [{"call_id": "c1", "name": "execute_python", "arguments": {"code": code, "_sandbox": {"private_workspace": "/", "posture": "any_except_denied"}}}]})
+    outcome = handler(run, effect, None)
+    res = outcome.result["results"][0]
+    out = res["output"]
+    assert MARK not in str(out)
+    assert out["sandbox"]["kind"] == "macos-sandbox-exec" and out["sandbox"]["refused"] == [str(t / "refused")]

{abstractagent-0.3.16 → abstractagent-0.3.18}/tests/test_history_monster_clamp.py

@@ -241,18 +241,23 @@ def _poison_tools(run: Any, effect: Effect, dnn: Any = None) -> EffectOutcome:
 
 def test_poisoned_visit_transcript_recovers_on_the_next_turn(tmp_path: Path) -> None:
     """End-to-end on the REAL merged lane (the incident's lane): turn 1
-    poisons the durable transcript with a ~495k tool message; turn 2's wire
-    payload carries a labeled 32k stub instead — the session recovers with
-    NO manual surgery while the durable record keeps the full truth."""
+    poisons the durable transcript with a ~495k tool message. Within turn 1
+    the result rides the next call clamped to OVERSIZED_MESSAGE_CLAMP_CHARS
+    (the newest turn is kept whole by the window). From turn 2 on, the visit
+    BRIDGE's history window (`_runtime.history_window_tokens`, runtime 0.7,
+    ADR-0026) drops the poisoned turn whole — call, result and reply — because
+    it no longer fits beside a newer turn: the request is the labeled notice
+    and the new words. The session recovers with NO manual surgery while the
+    durable record keeps the full truth."""
     pytest.importorskip("abstractmemory")
     from abstractruntime.identity.entity_runtime import open_entity_runtime
     from abstractruntime.identity.visit_workflow import (
         HARVEST_NODE,
-        VISIT_HISTORY_TOOL_RESULT_CAP_CHARS,
         VISITOR_WAIT_KEY,
         ReactMiddle,
         build_visit_workflow,
     )
+    from abstractruntime.turn_grounding import strip_turn_grounding
 
     home_dir = _make_home(tmp_path)
     llm = _ScriptedLLM([
@@ -312,20 +317,28 @@ def test_poisoned_visit_transcript_recovers_on_the_next_turn(tmp_path: Path) ->
         assert state.status == RunStatus.WAITING
         assert len(llm.calls) == 3
 
-        wire = llm.calls[2]["messages"]
-        wire_tool = [m for m in wire if m.get("role") == "tool"]
-        assert len(wire_tool) == 1
-        clamped = wire_tool[0]["content"]
-        assert len(clamped) <= VISIT_HISTORY_TOOL_RESULT_CAP_CHARS + 200
+        # Within turn 1, the call after the read carried the clamped stub.
+        in_turn_tool = [m for m in llm.calls[1]["messages"] if m.get("role") == "tool"]
+        assert len(in_turn_tool) == 1
+        clamped = in_turn_tool[0]["content"]
+        assert len(clamped) <= OVERSIZED_MESSAGE_CLAMP_CHARS + 200
         assert clamped.startswith("[read_file]: --- shared/Screenshot_2026-08-01"), "head kept - labeled, never dropped"
         assert "chars elided: oversized tool result" in clamped
-        # The visitor's words and the entity's own prose are untouched.
-        user_msgs = [m for m in wire if m.get("role") == "user"]
-        assert any("Are you still with me?" in str(m.get("content")) for m in user_msgs)
-        assert any(m.get("role") == "assistant" and "I looked at the file." == m.get("content") for m in wire)
-        # The whole request shrank from monster-class to sane.
+
+        # Turn 2: the poisoned turn is out of the request, whole, and says so.
+        wire = llm.calls[2]["messages"]
+        assert [m for m in wire if m.get("role") == "tool"] == []
+        assert not any(m.get("tool_calls") for m in wire)
+        assert len(wire) == 1 and wire[0]["role"] == "user"
+        # One head envelope (the turn's own), then the labeled drop notice.
+        assert wire[0]["content"].count("<runtime_metadata>") == 1
+        assert strip_turn_grounding(wire[0]["content"]).startswith("[#TRUNCATION: 4 earlier message(s)")
+        assert "Are you still with me?" in wire[0]["content"]
+        report = ert.runtime.get_state(run_id).vars["_runtime"]["session_history"]
+        assert report["dropped_messages"] == 4 and report["replayed_messages"] == 1
+        # The whole request shrank from monster-class to one short message.
         total = sum(len(str(m.get("content") or "")) for m in wire)
-        assert total < 100_000, f"recovered payload still huge: {total}"
+        assert total < 2_000, f"recovered payload still huge: {total}"
 
         # And the durable record STILL holds the full truth (ADR-0026).
         stored = ert.runtime.get_state(run_id).vars["context"]["messages"]

{abstractagent-0.3.16 → abstractagent-0.3.18}/tests/test_packaging_profiles.py

@@ -18,20 +18,20 @@ def _project() -> dict:
 def test_base_dependency_floors_match_gateway_alignment() -> None:
     deps = set(_project()["dependencies"])
 
-    assert "abstractcore[tools]>=2.13.41" in deps
-    assert "abstractruntime>=0.5.0" in deps
+    assert "abstractcore[tools]>=2.25.0" in deps
+    assert "abstractruntime>=0.7.0" in deps
 
 
 def test_hardware_profile_extras_are_core_runtime_cascades() -> None:
     extras = _project()["optional-dependencies"]
 
     assert set(extras["apple"]) == {
-        "abstractcore[all-apple]>=2.13.41",
-        "abstractruntime[apple]>=0.5.0",
+        "abstractcore[all-apple]>=2.25.0",
+        "abstractruntime[apple]>=0.7.0",
     }
     assert set(extras["gpu"]) == {
-        "abstractcore[all-gpu]>=2.13.41",
-        "abstractruntime[gpu]>=0.5.0",
+        "abstractcore[all-gpu]>=2.25.0",
+        "abstractruntime[gpu]>=0.7.0",
     }
     assert "all-apple" not in extras
     assert "all-gpu" not in extras

abstractagent-0.3.18/tests/test_react_history_window.py

@@ -0,0 +1,64 @@
+"""ReAct sends THE runtime history window when the host asks for it
+(`_runtime.history_window_tokens`; runtime 0.7.0's entity visit sets 50k).
+Unset, the whole transcript rides as before. The durable transcript is never
+windowed."""
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from abstractagent.adapters.react_runtime import create_react_workflow
+from abstractagent.logic.react import ReActLogic
+from abstractcore.tools import ToolDefinition
+from abstractruntime.core.models import Effect, EffectType, RunState, RunStatus
+from abstractruntime.core.runtime import EffectOutcome, Runtime
+from abstractruntime.storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
+from abstractruntime.turn_grounding import strip_turn_grounding
+
+OLD = [m for i in range(6) for m in ({"role": "user", "content": f"old {i} " + "w " * 2000},
+                                     {"role": "assistant", "content": f"reply {i}"})]
+
+
+def _run(runtime_vars: Dict[str, Any]) -> tuple:
+    captured: List[Dict[str, Any]] = []
+
+    def llm(run: RunState, effect: Effect, dnn: Optional[str]) -> EffectOutcome:
+        captured.append(json.loads(json.dumps(effect.payload)))
+        return EffectOutcome.completed({"content": "done", "tool_calls": []})
+
+    rt = Runtime(run_store=InMemoryRunStore(), ledger_store=InMemoryLedgerStore(),
+                 effect_handlers={EffectType.LLM_CALL: llm})
+    wf = create_react_workflow(logic=ReActLogic(tools=[ToolDefinition(name="t", description="t", parameters={})]),
+                               workflow_id="react_window", provider="stub", model="stub", allowed_tools=["t"])
+    messages = [dict(m) for m in OLD] + [{"role": "user", "content": "now"}]
+    run_id = rt.start(workflow=wf, vars={"context": {"task": "now", "messages": messages}, "_runtime": dict(runtime_vars)})
+    state = rt.tick(workflow=wf, run_id=run_id, max_steps=40)
+    assert state.status == RunStatus.COMPLETED
+    return captured[0]["messages"], state
+
+
+def test_the_window_key_windows_the_request_and_records_it() -> None:
+    wire, state = _run({"history_window_tokens": 3000})
+    report = state.vars["_runtime"]["session_history"]
+    assert report["max_tokens"] == 3000 and report["dropped_messages"] > 0
+    assert len(wire) == report["replayed_messages"] < len(OLD) + 1
+    assert strip_turn_grounding(wire[0]["content"]).startswith("[#TRUNCATION: ")
+    assert strip_turn_grounding(wire[-1]["content"]) == "now"
+    stored = state.vars["context"]["messages"]
+    assert len(stored) >= len(OLD) + 1 and stored[0]["content"].startswith("old 0 ")  # durable transcript whole
+
+
+def test_without_the_key_the_whole_transcript_rides() -> None:
+    wire, state = _run({})
+    assert "session_history" not in state.vars["_runtime"]
+    assert len(wire) == len(OLD) + 1 and wire[0]["content"].startswith("old 0 ")
+
+
+def test_the_turn_in_progress_is_kept_whole_from_the_hosts_turn_start() -> None:
+    """`_runtime.history_window_turn_start` marks where the turn in progress
+    began: from there on it is one turn, kept whole (and reported oversize),
+    however many user-role messages the loop added inside it."""
+    wire, state = _run({"history_window_tokens": 3000, "history_window_turn_start": 0})
+    report = state.vars["_runtime"]["session_history"]
+    assert report["dropped_messages"] == 0 and report["oversize_turn_kept"] is True
+    assert len(wire) == len(OLD) + 1 and wire[0]["content"].startswith("old 0 ")

abstractagent-0.3.16/src/abstractagent.egg-info/requires.txt

@@ -1,16 +0,0 @@
-abstractcore[tools]>=2.13.41
-abstractruntime>=0.5.0
-
-[apple]
-abstractcore[all-apple]>=2.13.41
-abstractruntime[apple]>=0.5.0
-
-[dev]
-pytest>=7.0
-
-[gpu]
-abstractcore[all-gpu]>=2.13.41
-abstractruntime[gpu]>=0.5.0
-
-[test]
-pytest>=7.0