aisolate-agent 0.3.4__tar.gz → 0.3.6__tar.gz

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisolate-agent
-Version: 0.3.4
+Version: 0.3.6
 Summary: AI Agent with intelligent planning and reasoning
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -30,7 +30,7 @@ AI Agent with intelligent planning and reasoning
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_agent-0.3.4-py3-none-any.whl
+pip install path/to/aisolate_agent-0.3.6-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/README.md

@@ -5,7 +5,7 @@ AI Agent with intelligent planning and reasoning
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_agent-0.3.4-py3-none-any.whl
+pip install path/to/aisolate_agent-0.3.6-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisolate-agent"
-version = "0.3.4"
+version = "0.3.6"
 description = "AI Agent with intelligent planning and reasoning"
 readme = "README.md"
 requires-python = ">=3.10"

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/agent.py

@@ -1501,6 +1501,9 @@ class Agent:
                 context.spine_compactor = SizeCompactor.from_settings(
                     self.settings
                 )
+                context.max_consecutive_failures = (
+                    self.settings.max_consecutive_failures
+                )
                 if context.remote_python_executor is not None:
                     context.remote_python_executor.output_window = (
                         self.settings.output_window_chars

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/config/agent_settings.py

@@ -18,6 +18,14 @@ class AgentSettings(BaseSettings):
         default=3,
         description="Maximum number of recovery attempts for failed operations",
     )
+    max_consecutive_failures: int = Field(
+        default=5,
+        description=(
+            "Consecutive failed tool executions (regardless of error text) "
+            "tolerated before the stall ladder intervenes; 0 disables the "
+            "failure signal"
+        ),
+    )
 
     debug_mode: bool = Field(
         default=False, description="Enable debug logging and additional validation"

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/core/context.py

@@ -333,6 +333,11 @@ class AgentContext:
         # first turn's reported usage.
         self.spine_compactor: Optional[Any] = None
 
+        # Consecutive-failure threshold for the executing ledger, stamped
+        # from AgentSettings by the run owner alongside spine_compactor.
+        # None = the ledger's own default; 0 disables the signal.
+        self.max_consecutive_failures: Optional[int] = None
+
         # The user's locale (AgentSettings.locale), stamped by the run owner
         # like workspace_root_display; the identity block renders it so
         # number/date/time formatting in user-facing output follows the

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/core/spine_compaction.py

@@ -184,6 +184,13 @@ def build_summary(context: "AgentContext", dropped: Sequence[Event]) -> str:
         "disk (re-read it when needed), and your checklist, memory, and "
         "workspace listing render below as always."
     ]
+    if getattr(context, "remote_python_executor", None) is not None:
+        lines.append(
+            "The source of the condensed cells is still in the kernel: "
+            "successful cells are collected in .aisolate/cells_ok.py, and "
+            "%history / In[n] hold the full input history — recover code "
+            "from there instead of rewriting it from memory."
+        )
 
     finished = [
         rec

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/states/executing.py

@@ -2,6 +2,7 @@
 
 import json
 import os
+import re
 from typing import Any, Dict, List, Optional, Set, Tuple, TYPE_CHECKING
 
 from openai_harmony import Role
@@ -84,10 +85,12 @@ class ProgressLedger:
     """One progress ledger per executing run — two signals, one owner.
 
     Signal 1 (terminal): the exact no-progress count. A turn with no action,
-    or a byte-identical repeated observation, increments it; a novel
-    observation or a drafted answer resets it; at ``MAX_NO_PROGRESS`` the run
-    stalls. This is the only signal allowed to end a run — it proves zero
-    information gain.
+    or a repeated observation, increments it; a novel observation or a
+    drafted answer resets it; at ``MAX_NO_PROGRESS`` the run stalls. This is
+    the only signal allowed to end a run — it proves zero information gain.
+    Repeat identity ignores nondeterministic tokens (UUIDs, long hex ids,
+    memory addresses): a retried upload whose object name embeds a fresh
+    ``uuid4().hex`` per attempt is the same failure, not new information.
 
     Signal 2 (advisory): the checklist stall clock. Every executing turn
     observes the ``task.md`` fingerprint; once it has not advanced for
@@ -96,22 +99,48 @@ class ProgressLedger:
     ``CHECKLIST_REMINDER_EVERY`` further stalled turns. It never terminates
     the run — budget exhaustion is an honest, recoverable outcome, and a
     coarse heuristic must not kill legitimately long single-item work.
+
+    Signal 3 (terminal, shares the ladder): consecutive failed executions.
+    Repeat identity misses a wedge whose error text genuinely shifts between
+    attempts; a run that cannot execute ANYTHING successfully for
+    ``max_consecutive_failures`` turns is wedged regardless. One success
+    resets the count. The threshold is settable per run
+    (``AgentSettings.max_consecutive_failures``); 0 disables.
     """
 
     #: Consecutive no-progress turns tolerated before the run stalls.
     MAX_NO_PROGRESS = 5
 
+    #: Default consecutive failed executions tolerated before escalation.
+    MAX_CONSECUTIVE_FAILURES = 5
+
     #: Executing turns without checklist advance before the notice fires.
     CHECKLIST_STALL_TURNS = 8
 
     #: Further stalled turns between notice repetitions.
     CHECKLIST_REMINDER_EVERY = 4
 
+    #: Nondeterministic tokens scrubbed before repeat comparison: memory
+    #: addresses, dashed UUIDs, and long hex runs (``uuid4().hex`` object
+    #: names, digests). The hex rule requires at least one a-f letter so
+    #: plain large numbers (real data) never collapse into a false repeat.
+    _NONDETERMINISTIC = re.compile(
+        r"0x[0-9a-fA-F]{4,}"
+        r"|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+        r"|(?=[0-9]*[a-f])[0-9a-f]{16,}"
+    )
+
     def __init__(self) -> None:
         self.no_progress_count: int = 0
         self._seen_results: Set[str] = set()
         self._checklist_fingerprint: Optional[str] = None
         self._stall_turns: int = 0
+        self.max_consecutive_failures: int = self.MAX_CONSECUTIVE_FAILURES
+        self.consecutive_failures: int = 0
+
+    @classmethod
+    def _fingerprint(cls, observation: str) -> str:
+        return cls._NONDETERMINISTIC.sub("•", observation)
 
     # -- signal 2: checklist stall clock ---------------------------------
 
@@ -159,11 +188,12 @@ class ProgressLedger:
     # -- signal 1: exact no-progress count --------------------------------
 
     def observe_result(self, compacted: str) -> bool:
-        """Account one observation; ``True`` for a byte-identical repeat."""
-        if compacted in self._seen_results:
+        """Account one observation; ``True`` for a repeat (up to random ids)."""
+        fingerprint = self._fingerprint(compacted)
+        if fingerprint in self._seen_results:
             self.no_progress_count += 1
             return True
-        self._seen_results.add(compacted)
+        self._seen_results.add(fingerprint)
         self.no_progress_count = 0
         return False
 
@@ -176,8 +206,38 @@ class ProgressLedger:
         self.no_progress_count = 0
 
     def reset_counter(self) -> None:
-        """Start a fresh no-progress window (stall recovery granted)."""
+        """Start a fresh window on both terminal signals (recovery granted)."""
         self.no_progress_count = 0
+        self.consecutive_failures = 0
+
+    # -- signal 3: consecutive failed executions ---------------------------
+
+    def observe_failure(self, ok: bool) -> None:
+        """Account one execution outcome; a success resets the streak."""
+        self.consecutive_failures = 0 if ok else self.consecutive_failures + 1
+
+    @property
+    def failure_stalled(self) -> bool:
+        return (
+            self.max_consecutive_failures > 0
+            and self.consecutive_failures >= self.max_consecutive_failures
+        )
+
+    def failure_notice(self) -> Optional[str]:
+        """In-band warning on the two failures before the threshold."""
+        if self.max_consecutive_failures <= 0:
+            return None
+        remaining = self.max_consecutive_failures - self.consecutive_failures
+        if remaining <= 0 or remaining > 2:
+            return None
+        return (
+            f"\n[framework notice] {self.consecutive_failures} consecutive "
+            "executions have failed. If the blocker is external (a service "
+            "down, missing data), stop retrying — record it and work on "
+            "something else or deliver with the gap named. After "
+            f"{remaining} more consecutive failure(s) the framework "
+            "intervenes."
+        )
 
     def clear_seen(self) -> None:
         """Forget seen observations (a re-planned cycle starts clean)."""
@@ -190,8 +250,9 @@ class ProgressLedger:
     def repeat_notice(self, remaining: int) -> str:
         """The in-band first response to a repeated observation."""
         return (
-            "\n[framework notice] This result is byte-identical to an "
-            "earlier one in this run — the call added no new information. "
+            "\n[framework notice] This result is identical to an earlier "
+            "one in this run (ignoring random identifiers) — the call added "
+            "no new information. "
             f"After {remaining} more repeated result(s) the framework "
             "intervenes and will eventually end the run. If the task is "
             "complete, deliver NOW by calling final_answer(...); otherwise "
@@ -281,6 +342,10 @@ class ExecutingState(AbstractState):
         context.set_state_hint("tool_choice", "required")
         context.set_state_hint("reasoning_effort", "medium")
 
+        limit = getattr(context, "max_consecutive_failures", None)
+        if limit is not None:
+            self._ledger.max_consecutive_failures = limit
+
         # Remove HITL tools — clarification phase is over, the agent must
         # execute autonomously. Keeping ask_user available tempts the LLM
         # into asking trivial preference questions mid-execution; there is
@@ -503,12 +568,18 @@ class ExecutingState(AbstractState):
         truncated = len(compacted) < len(output)
 
         # Progress accounting on the STORED result bytes (the pre-annotation
-        # compacted form): a byte-identical repeat added zero new information
-        # to the trace. The first response is in-band — the model is told, in
-        # the observation itself, that it is repeating and how to deliver.
+        # compacted form, normalized for random ids): a repeat added zero new
+        # information to the trace. The first response is in-band — the model
+        # is told, in the observation itself, that it is repeating and how to
+        # deliver.
         # Only a model that ignores the notice until the threshold stalls the
         # run; the crossing repeat emits nothing, it had nothing to add.
-        if self._ledger.observe_result(compacted):
+        # Both terminal signals observe every result; at most ONE escalates a
+        # turn (a repeated failure is also a failure — climbing both ladders
+        # at once would skip rungs).
+        repeated_observation = self._ledger.observe_result(compacted)
+        self._ledger.observe_failure(ok)
+        if repeated_observation:
             logger.warning(
                 "Repeated observation adds no new information",
                 state="executing",
@@ -528,6 +599,25 @@ class ExecutingState(AbstractState):
                     - self._ledger.no_progress_count
                 )
                 compacted += self._ledger.repeat_notice(remaining)
+        elif self._ledger.failure_stalled:
+            logger.warning(
+                "Consecutive execution failures crossed the threshold",
+                state="executing",
+                consecutive_failures=self._ledger.consecutive_failures,
+            )
+            stalled = self._escalate_stall(
+                context, repeated=tool_name, reason="failures"
+            )
+            if stalled is not None:
+                return stalled
+            compacted += (
+                "\n[framework notice] Course change required — follow "
+                "the steering instruction below."
+            )
+        else:
+            failure_notice = self._ledger.failure_notice()
+            if failure_notice is not None:
+                compacted += failure_notice
 
         stall_notice = self._ledger.checklist_stall_notice()
         if stall_notice is not None:
@@ -549,30 +639,48 @@ class ExecutingState(AbstractState):
         )
 
     def _escalate_stall(
-        self, context: "AgentContext", repeated: str
+        self, context: "AgentContext", repeated: str, reason: str = "repeat"
     ) -> Optional[Stalled]:
         """Advance the stall ladder one rung; ``None`` grants a recovery.
 
+        Both terminal signals share the ONE ladder position
+        (``context.stall_recoveries``); ``reason`` selects the steering text
+        ("repeat" = identical observations, "failures" = consecutive failed
+        executions).
+
         Rung 1: steering + fresh no-progress window, the loop continues.
         Rung 2: re-plan steering, ``Stalled`` routes to planning.
         Rung 3: ``Stalled`` routes to finished — the run ends, loudly.
         """
         context.stall_recoveries += 1
         rung = context.stall_recoveries
-        count = self._ledger.no_progress_count
+        count = (
+            self._ledger.consecutive_failures
+            if reason == "failures"
+            else self._ledger.no_progress_count
+        )
         logger.warning(
             "Stall threshold crossed",
             state="executing",
             escalation=rung,
-            no_progress_count=count,
+            reason=reason,
+            count=count,
             repeated=repeated,
         )
         if rung == 1:
-            self._pending_steering = self._recovery_steering(repeated, count)
+            self._pending_steering = (
+                self._failure_recovery_steering(repeated, count)
+                if reason == "failures"
+                else self._recovery_steering(repeated, count)
+            )
             self._ledger.reset_counter()
             return None
         if rung == 2:
-            self._pending_steering = self._replan_steering(repeated)
+            self._pending_steering = (
+                self._failure_replan_steering(repeated, count)
+                if reason == "failures"
+                else self._replan_steering(repeated)
+            )
             self._ledger.reset_counter()
             self._ledger.clear_seen()
         return Stalled(text="", no_progress_count=count)
@@ -593,6 +701,34 @@ class ExecutingState(AbstractState):
             "partial results, naming exactly what is missing and why."
         )
 
+    @staticmethod
+    def _failure_recovery_steering(tool: str, count: int) -> str:
+        return (
+            "[framework steering — repeated failures] The last "
+            f"{count} '{tool}' executions ALL failed. Whatever you are "
+            "retrying is not going to succeed by repetition. Decide now:\n"
+            "1. If the blocker is external (a service or endpoint down, "
+            "missing data), STOP calling it — record the blocker "
+            "(write_memory) and continue with work that does not need it.\n"
+            "2. If your code is failing, step back: print the intermediate "
+            "state, simplify to a minimal version, and rebuild from what "
+            "works.\n"
+            "3. If nothing can proceed, call final_answer with your best "
+            "partial results, naming exactly what is blocked and why."
+        )
+
+    @staticmethod
+    def _failure_replan_steering(tool: str, count: int) -> str:
+        return (
+            "[framework steering — approach failed] Executions kept failing "
+            f"(last {count} '{tool}' calls) despite a corrective "
+            "instruction: the current plan's approach is not working. "
+            "Re-plan now. In the revised plan: treat the failing "
+            "step/service as unavailable and route around it; reuse the "
+            "workspace results that already exist instead of redoing "
+            "completed work."
+        )
+
     @staticmethod
     def _replan_steering(repeated: str) -> str:
         return (

{aisolate_agent-0.3.4 → aisolate_agent-0.3.6}/src/aisolate/agent/tests/test_core/test_spine_compaction.py

@@ -222,6 +222,20 @@ def test_summary_carries_registry_and_failure_lines():
     assert "Boom: file not found" in summary
 
 
+def test_summary_points_at_kernel_history_on_the_jupyter_lane():
+    log = _spine_log(2)
+    dropped = select_settled_range(
+        log.events(), keep_recent_pairs=0, target_tokens=10_000
+    )
+    jupyter_ctx = SimpleNamespace(conversation=log, remote_python_executor=object())
+    summary = build_summary(jupyter_ctx, dropped)
+    assert ".aisolate/cells_ok.py" in summary
+    assert "%history" in summary
+
+    shell_ctx = SimpleNamespace(conversation=log)
+    assert "%history" not in build_summary(shell_ctx, dropped)
+
+
 def test_squash_event_shape_matches_the_view_contracts():
     """kernel author + ok:True + no tool_call_id: passes paired_tools_only,
     passes ok_code_only (the acceptance view), renders as a TOOL turn."""

aisolate_agent-0.3.6/src/aisolate/agent/tests/test_package_import_surface.py

@@ -0,0 +1,30 @@
+"""Package-boundary checks for the independently released agent."""
+
+import subprocess
+import sys
+import textwrap
+
+
+def test_agent_imports_without_sandbox_package():
+    script = textwrap.dedent(
+        """
+        import sys
+
+        class SandboxBlocker:
+            def find_spec(self, name, path=None, target=None):
+                if name == "aisolate.sandbox" or name.startswith("aisolate.sandbox."):
+                    raise ModuleNotFoundError("aisolate.sandbox is not part of aisolate-agent")
+
+        sys.meta_path.insert(0, SandboxBlocker())
+
+        import aisolate.agent
+        """
+    )
+    process = subprocess.run(
+        [sys.executable, "-c", script],
+        capture_output=True,
+        text=True,
+        timeout=120,
+        check=False,
+    )
+    assert process.returncode == 0, process.stderr