AbstractAgent 0.3.18__tar.gz → 0.3.19__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.18
+Version: 0.3.19
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "abstractagent"
-version = "0.3.18"
+version = "0.3.19"
 description = "Agent implementations using AbstractRuntime and AbstractCore"
 readme = "README.md"
 requires-python = ">=3.10"

{abstractagent-0.3.18 → abstractagent-0.3.19}/src/abstractagent/adapters/emit_inventory.py

@@ -85,6 +85,12 @@ REACT_STEPS = COMMON_STEPS | frozenset(
         "parse_retry_empty",
         "parse_retry_plan_only",
         "parse_retry_truncated",
+        # Tool-call format repair (2026-10-03, shipped round 14): AbstractCore
+        # reported `metadata.tool_call_error` (code invalid_tool_syntax |
+        # unavailable_tool) and accepted ZERO calls; the model is asked once
+        # more with the tool roster — payload {cycle, attempt, code}. At most
+        # two per turn; the third raises (the run fails with the sentence).
+        "parse_retry_tool_format",
         # 0017 work half (2026-07-21), nudge-then-stop (2026-08-21): fires on
         # every detection of a consecutive-identical or A-B-A-B tool-batch
         # streak; payload {kind: repeat|oscillation, span, key, answered,

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

@@ -1446,6 +1446,10 @@ def reset_react_turn(run_vars: Dict[str, Any]) -> None:
             # retry stash is the same lifecycle class.
             "pending_media",
             "last_call_media",
+            # Tool-call format repair budget is per TURN (two retries each):
+            # without this pop, two format failures anywhere in a conversation
+            # made every later failing turn raise at once.
+            "tool_format_retries",
         ):
             temp.pop(key, None)
 
@@ -2496,6 +2500,36 @@ def create_react_workflow(
             emit("parse_tool_calls", {"count": len(tool_calls)})
             return StepPlan(node_id="parse", next_node="act")
 
+        # Core owns syntax recognition; the agent owns bounded recovery. Retry
+        # only when zero calls were accepted, so a partial batch is never replayed.
+        metadata = response.get("metadata") if isinstance(response, dict) else None
+        tool_error = metadata.get("tool_call_error") if isinstance(metadata, dict) else None
+        if isinstance(tool_error, dict) and tool_error.get("code") in {"invalid_tool_syntax", "unavailable_tool"}:
+            retries = int(temp.get("tool_format_retries", 0) or 0)
+            if retries >= 2 or cycle_i >= max_iterations:
+                raise RuntimeError("Tool-call format repair failed: no executable tool calls after bounded retries.")
+            specs = runtime_ns.get("tool_specs") or []
+            names = [str(spec["name"]) for spec in specs if isinstance(spec, dict) and spec.get("name")]
+            if not names:
+                raise RuntimeError("The model attempted a tool call, but this run has no tools configured.")
+            temp["tool_format_retries"] = retries + 1
+            _push_inbox(
+                runtime_ns,
+                "Your previous tool call was rejected; nothing was executed. "
+                "Use only the available tools: " + ", ".join(names) + ". "
+                # No format of our own: the tool-calling format is the one the
+                # request's instructions carry (native structured calls, or the
+                # provider's prompted text format) — a hard-coded text syntax
+                # here would teach a native tool-calling model the wrong one.
+                "Follow the tool-calling format and argument schemas supplied in the instructions, "
+                "with an actual available tool name and valid arguments. "
+                "Emit the corrected call now, or explain why you cannot complete the task without it.",
+            )
+            emit("parse_retry_tool_format", {"cycle": cycle_i, "attempt": retries + 1, "code": tool_error["code"]})
+            if last_call_media:
+                temp["pending_media"] = last_call_media
+            return StepPlan(node_id="parse", next_node="reason")
+
         # If the model hit an output limit, treat the step as incomplete and continue.
         # Retry-nudge lane honesty (iteration-3 adversary P0, 2026-07-19 — the
         # c2447 chrome class at the PARSE boundary): these nudges ride the

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.18
+Version: 0.3.19
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

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

@@ -103,6 +103,7 @@ tests/test_react_phase_grant_boundary.py
 tests/test_react_planish_heuristic.py
 tests/test_react_prompt_prefix_stability.py
 tests/test_react_sight_lane_media_fold.py
+tests/test_react_tool_format_retry.py
 tests/test_react_turn_byte_stability.py
 tests/test_react_verifier_and_plan.py
 tests/test_react_visit_composition.py

abstractagent-0.3.19/tests/test_react_tool_format_retry.py

@@ -0,0 +1,106 @@
+from typing import Any
+
+import pytest
+
+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 EffectType, RunStatus
+from abstractruntime.core.runtime import EffectOutcome, Runtime
+from abstractruntime.storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
+
+
+@pytest.mark.parametrize("recover", [False, True])
+def test_format_repair_is_bounded_and_never_executes_rejected_calls(recover):
+    requests: list[dict[str, Any]] = []
+    executed = []
+
+    def llm(run, effect, next_node):
+        requests.append(effect.payload)
+        if len(requests) > 1:
+            assert "nothing was executed" in str(effect.payload["messages"])
+            # The repair names no text format of its own (a native tool-calling
+            # provider must never be taught a text syntax): it points at the
+            # request's own instructions and lists the roster.
+            assert "<tool_call>" not in str(effect.payload["messages"])
+            assert "format and argument schemas supplied in the instructions" in str(effect.payload["messages"])
+            assert "Use only the available tools: web_search." in str(effect.payload["messages"])
+        if recover and len(requests) == 2:
+            return EffectOutcome.completed({"content": "", "tool_calls": [{"name": "web_search", "arguments": {"query": "test"}, "call_id": "one"}]})
+        if recover and len(requests) == 3:
+            return EffectOutcome.completed({"content": "Found it."})
+        return EffectOutcome.completed({"content": "Broken tool block", "metadata": {
+            "tool_call_error": {"code": "invalid_tool_syntax", "available_tools": ["web_search"]}}})
+
+    def tool(run, effect, next_node):
+        executed.extend(effect.payload["tool_calls"])
+        return EffectOutcome.completed({"mode": "executed", "results": [{"name": "web_search", "call_id": "one", "success": True, "output": "found"}]})
+
+    runtime = Runtime(run_store=InMemoryRunStore(), ledger_store=InMemoryLedgerStore(),
+                      effect_handlers={EffectType.LLM_CALL: llm, EffectType.TOOL_CALLS: tool})
+    workflow = create_react_workflow(logic=ReActLogic(tools=[ToolDefinition(name="web_search", description="Search", parameters={"query": {"type": "string"}})]),
+                                    workflow_id="format-repair", provider="stub", model="stub", allowed_tools=["web_search"])
+    rid = runtime.start(workflow=workflow, vars={"context": {"task": "Search", "messages": []}, "_runtime": {"inbox": []}})
+    def drive():
+        for _ in range(80):
+            state = runtime.tick(workflow=workflow, run_id=rid, max_steps=1)
+            if state.status in (RunStatus.COMPLETED, RunStatus.FAILED):
+                return state
+    if recover:
+        assert drive().status == RunStatus.COMPLETED
+    else:
+        # GatewayRunner persists planning exceptions as FAILED (tick_exception).
+        with pytest.raises(RuntimeError, match="format repair failed"):
+            drive()
+    assert len(requests) == 3
+    assert len(executed) == (1 if recover else 0)
+
+
+def test_format_repair_budget_is_per_turn_in_a_composed_conversation():
+    """Two turns of one run (visit composition): each turn has two rejected formats and
+    still recovers. Without `reset_react_turn` clearing `tool_format_retries`, turn 2's
+    first rejection would raise at once (the budget was per conversation)."""
+    from abstractagent.adapters.react_runtime import reset_react_turn
+    from abstractruntime.core.models import StepPlan
+    from abstractruntime.core.spec import WorkflowSpec
+
+    bad = {"content": "Broken tool block", "metadata": {"tool_call_error": {"code": "invalid_tool_syntax", "available_tools": ["web_search"]}}}
+    script = [bad, bad, {"content": "Answer one."}, bad, bad, {"content": "Answer two."}]
+    calls = {"n": 0}
+    events: list[str] = []
+    answers: list[str] = []
+
+    def llm(run, effect, next_node):
+        i = calls["n"]
+        calls["n"] += 1
+        return EffectOutcome.completed(dict(script[min(i, len(script) - 1)]))
+
+    react = create_react_workflow(
+        logic=ReActLogic(tools=[ToolDefinition(name="web_search", description="Search", parameters={"query": {"type": "string"}})]),
+        workflow_id="format-repair-turns", provider="stub", model="stub", allowed_tools=["web_search"],
+        final_next_node="park", on_step=lambda step, data: events.append(step),
+    )
+
+    def park(run, ctx):
+        temp = run.vars.get("_temp") or {}
+        answers.append(str(temp.get("final_answer") or ""))
+        if len(answers) >= 2:
+            return StepPlan(node_id="park", complete_output={"turns": len(answers)})
+        reset_react_turn(run.vars)
+        run.vars["context"]["messages"].append({"role": "user", "content": "Second message"})
+        return StepPlan(node_id="park", next_node="reason")
+
+    nodes = dict(react.nodes)
+    nodes["park"] = park
+    workflow = WorkflowSpec(workflow_id=react.workflow_id, entry_node=react.entry_node, nodes=nodes)
+    runtime = Runtime(run_store=InMemoryRunStore(), ledger_store=InMemoryLedgerStore(), effect_handlers={EffectType.LLM_CALL: llm})
+    rid = runtime.start(workflow=workflow, vars={"context": {"task": "First message", "messages": []}, "_runtime": {"inbox": []}})
+    state = None
+    for _ in range(120):
+        state = runtime.tick(workflow=workflow, run_id=rid, max_steps=1)
+        if state.status in (RunStatus.COMPLETED, RunStatus.FAILED):
+            break
+    assert state is not None and state.status == RunStatus.COMPLETED, state
+    assert answers == ["Answer one.", "Answer two."]
+    assert events.count("parse_retry_tool_format") == 4
+    assert calls["n"] == 6