AbstractAgent 0.3.18__tar.gz → 0.4.0__tar.gz

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

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.18
+Version: 0.4.0
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: abstractcore[tools]>=2.25.0
-Requires-Dist: abstractruntime>=0.7.0
+Requires-Dist: abstractcore[tools]>=2.30.0
+Requires-Dist: abstractruntime>=0.12.0
 Provides-Extra: apple
-Requires-Dist: abstractcore[all-apple]>=2.25.0; extra == "apple"
-Requires-Dist: abstractruntime[apple]>=0.7.0; extra == "apple"
+Requires-Dist: abstractcore[all-apple]>=2.30.0; extra == "apple"
+Requires-Dist: abstractruntime[apple]>=0.12.0; extra == "apple"
 Provides-Extra: gpu
-Requires-Dist: abstractcore[all-gpu]>=2.25.0; extra == "gpu"
-Requires-Dist: abstractruntime[gpu]>=0.7.0; extra == "gpu"
+Requires-Dist: abstractcore[all-gpu]>=2.30.0; extra == "gpu"
+Requires-Dist: abstractruntime[gpu]>=0.12.0; extra == "gpu"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: test
@@ -68,6 +68,9 @@ flowchart LR
 - **Generation controls**: temperature, seed, media policy, prompt-cache
   identity, streaming, Core `thinking` and `speculation` (MTP) are normalized
   before LLM calls and inherited by delegated children
+- **Scheduled runs** (ReAct): the `schedule_run` tool schedules work or a reminder
+  for later in the same conversation, with at most the agent's tools (see
+  [`docs/tools.md`](docs/tools.md))
 - **Observability**: durable ledger of LLM calls, tool calls, and waits
 
 Where this lives in code (source of truth):
@@ -105,13 +108,11 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-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.
+AbstractAgent 0.4.0 requires `abstractcore[tools]>=2.30.0` and
+`AbstractRuntime>=0.12.0` (the runtime release with the `SCHEDULE_RUN` effect
+behind the ReAct `schedule_run` tool, on top of the 50k-token history window
+that ReAct applies when a host sets `_runtime.history_window_tokens`, live token
+streaming, turn grounding, in-flight cancellation and speculation inheritance).
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

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

@@ -47,6 +47,9 @@ flowchart LR
 - **Generation controls**: temperature, seed, media policy, prompt-cache
   identity, streaming, Core `thinking` and `speculation` (MTP) are normalized
   before LLM calls and inherited by delegated children
+- **Scheduled runs** (ReAct): the `schedule_run` tool schedules work or a reminder
+  for later in the same conversation, with at most the agent's tools (see
+  [`docs/tools.md`](docs/tools.md))
 - **Observability**: durable ledger of LLM calls, tool calls, and waits
 
 Where this lives in code (source of truth):
@@ -84,13 +87,11 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-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.
+AbstractAgent 0.4.0 requires `abstractcore[tools]>=2.30.0` and
+`AbstractRuntime>=0.12.0` (the runtime release with the `SCHEDULE_RUN` effect
+behind the ReAct `schedule_run` tool, on top of the 50k-token history window
+that ReAct applies when a host sets `_runtime.history_window_tokens`, live token
+streaming, turn grounding, in-flight cancellation and speculation inheritance).
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

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

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

{abstractagent-0.3.18 → abstractagent-0.4.0}/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.4.0}/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)
 
@@ -1736,6 +1740,7 @@ def create_react_workflow(
         "remember_note",
         "compact_memory",
         "delegate_agent",
+        "schedule_run",
         "update_plan",
     }
 
@@ -2496,6 +2501,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
@@ -3012,6 +3047,31 @@ def create_react_workflow(
                     next_node="observe",
                 )
 
+            if name == "schedule_run":
+                # Framework backlog 1045: a run LATER (at a time, after a delay, or on a trigger
+                # event) with at most this run's tools, never schedule_run itself (no recursion,
+                # like delegate_agent). The runtime intersects again with the run tree's ceiling
+                # and the host creates the one-shot automation (EffectType.SCHEDULE_RUN).
+                tools_raw = args.get("tools")
+                if tools_raw is None:
+                    wake_tools = [t for t in allow if t != "schedule_run"]
+                else:
+                    parent_allow = set(allow)
+                    wake_tools = [t for t in _normalize_allowlist(tools_raw) if t in parent_allow and t != "schedule_run"]
+                payload = {
+                    k: args[k]
+                    for k in ("at", "after_s", "on", "task", "note", "mode", "title", "notify")
+                    if args.get(k) is not None
+                }
+                payload["tools"] = wake_tools
+                payload["tool_name"] = "schedule_run"
+                payload["call_id"] = str(tc.get("call_id") or "")
+                return StepPlan(
+                    node_id="act",
+                    effect=Effect(type=EffectType.SCHEDULE_RUN, payload=payload, result_key="_temp.tool_results"),
+                    next_node="observe",
+                )
+
             # Unknown builtin: continue.
             return StepPlan(node_id="act", next_node="act" if temp.get("pending_tool_calls") else "reason")
 

{abstractagent-0.3.18 → abstractagent-0.4.0}/src/abstractagent/agents/react.py

@@ -24,6 +24,7 @@ from ..logic.builtins import (
     ASK_USER_TOOL,
     COMPACT_MEMORY_TOOL,
     DELEGATE_AGENT_TOOL,
+    SCHEDULE_RUN_TOOL,
     INSPECT_VARS_TOOL,
     OPEN_ATTACHMENT_TOOL,
     RECALL_MEMORY_TOOL,
@@ -121,6 +122,7 @@ class ReactAgent(BaseAgent):
             REMEMBER_NOTE_TOOL,
             COMPACT_MEMORY_TOOL,
             DELEGATE_AGENT_TOOL,
+            SCHEDULE_RUN_TOOL,
             UPDATE_PLAN_TOOL,
             *tool_defs,
         ]

{abstractagent-0.3.18 → abstractagent-0.4.0}/src/abstractagent/logic/builtins.py

@@ -364,3 +364,66 @@ DELEGATE_AGENT_TOOL = ToolDefinition(
         "inspect a few files, search for specific symbols, summarize findings)."
     ),
 )
+
+SCHEDULE_RUN_TOOL = ToolDefinition(
+    name="schedule_run",
+    description="Schedule a run for later (at a time, after a delay, or on a trigger event) with a task or a reminder note.",
+    parameters={
+        "after_s": {
+            "type": "number",
+            "description": "Start this many seconds from now (e.g. 300 for five minutes). Give one of after_s, at or on.",
+            "default": None,
+        },
+        "at": {
+            "type": "string",
+            "description": "Start at this time: an RFC 3339 timestamp with its offset, e.g. 2026-10-26T09:00:00+01:00.",
+            "default": None,
+        },
+        "on": {
+            "type": "object",
+            "description": (
+                "Start when a trigger event arrives: {source_id, source_version?, connection_id?, config?}, "
+                "e.g. {\"source_id\": \"feed.item\", \"connection_id\": \"tc_...\"}. One run, on the first event."
+            ),
+            "default": None,
+        },
+        "task": {
+            "type": "string",
+            "description": "What the scheduled run should do (self-contained). Give a task or a note.",
+            "default": None,
+        },
+        "note": {
+            "type": "string",
+            "description": "A reminder to bring back to the person at that time (no tools are used).",
+            "default": None,
+        },
+        "tools": {
+            "type": "array",
+            "items": {"type": "string"},
+            "description": "Tools the scheduled run may use (a subset of yours). When omitted it inherits yours.",
+            "default": None,
+        },
+        "mode": {
+            "type": "string",
+            "description": "same_session (default: a new turn of this conversation) or independent (a fresh conversation).",
+            "default": "same_session",
+        },
+        "title": {
+            "type": "string",
+            "description": "A short title for the scheduled run (optional).",
+            "default": None,
+        },
+        "notify": {
+            "type": "boolean",
+            "description": (
+                "Send the person a notification with the scheduled run's answer (optional). Default: true "
+                "for a note (a reminder reaches them), false for a task."
+            ),
+            "default": None,
+        },
+    },
+    when_to_use=(
+        "Use when the person asks to be reminded later, or when work must happen later or when something "
+        "arrives. The run joins this conversation by default, with at most your tools."
+    ),
+)

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

@@ -1,18 +1,18 @@
 Metadata-Version: 2.4
 Name: abstractagent
-Version: 0.3.18
+Version: 0.4.0
 Summary: Agent implementations using AbstractRuntime and AbstractCore
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: abstractcore[tools]>=2.25.0
-Requires-Dist: abstractruntime>=0.7.0
+Requires-Dist: abstractcore[tools]>=2.30.0
+Requires-Dist: abstractruntime>=0.12.0
 Provides-Extra: apple
-Requires-Dist: abstractcore[all-apple]>=2.25.0; extra == "apple"
-Requires-Dist: abstractruntime[apple]>=0.7.0; extra == "apple"
+Requires-Dist: abstractcore[all-apple]>=2.30.0; extra == "apple"
+Requires-Dist: abstractruntime[apple]>=0.12.0; extra == "apple"
 Provides-Extra: gpu
-Requires-Dist: abstractcore[all-gpu]>=2.25.0; extra == "gpu"
-Requires-Dist: abstractruntime[gpu]>=0.7.0; extra == "gpu"
+Requires-Dist: abstractcore[all-gpu]>=2.30.0; extra == "gpu"
+Requires-Dist: abstractruntime[gpu]>=0.12.0; extra == "gpu"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Provides-Extra: test
@@ -68,6 +68,9 @@ flowchart LR
 - **Generation controls**: temperature, seed, media policy, prompt-cache
   identity, streaming, Core `thinking` and `speculation` (MTP) are normalized
   before LLM calls and inherited by delegated children
+- **Scheduled runs** (ReAct): the `schedule_run` tool schedules work or a reminder
+  for later in the same conversation, with at most the agent's tools (see
+  [`docs/tools.md`](docs/tools.md))
 - **Observability**: durable ledger of LLM calls, tool calls, and waits
 
 Where this lives in code (source of truth):
@@ -105,13 +108,11 @@ Native Python hardware profile cascades are available for deployment manifests:
 AbstractCore and AbstractRuntime profiles; AbstractAgent itself remains
 provider/runtime agnostic.
 
-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.
+AbstractAgent 0.4.0 requires `abstractcore[tools]>=2.30.0` and
+`AbstractRuntime>=0.12.0` (the runtime release with the `SCHEDULE_RUN` effect
+behind the ReAct `schedule_run` tool, on top of the 50k-token history window
+that ReAct applies when a host sets `_runtime.history_window_tokens`, live token
+streaming, turn grounding, in-flight cancellation and speculation inheritance).
 
 Note: the repository may be ahead of the latest published PyPI release. To verify what you installed:
 

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

@@ -102,7 +102,9 @@ tests/test_react_max_iterations_concludes.py
 tests/test_react_phase_grant_boundary.py
 tests/test_react_planish_heuristic.py
 tests/test_react_prompt_prefix_stability.py
+tests/test_react_schedule_run_tool.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.4.0/src/abstractagent.egg-info/requires.txt

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

{abstractagent-0.3.18 → abstractagent-0.4.0}/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.25.0" in deps
-    assert "abstractruntime>=0.7.0" in deps
+    assert "abstractcore[tools]>=2.30.0" in deps
+    assert "abstractruntime>=0.12.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.25.0",
-        "abstractruntime[apple]>=0.7.0",
+        "abstractcore[all-apple]>=2.30.0",
+        "abstractruntime[apple]>=0.12.0",
     }
     assert set(extras["gpu"]) == {
-        "abstractcore[all-gpu]>=2.25.0",
-        "abstractruntime[gpu]>=0.7.0",
+        "abstractcore[all-gpu]>=2.30.0",
+        "abstractruntime[gpu]>=0.12.0",
     }
     assert "all-apple" not in extras
     assert "all-gpu" not in extras

abstractagent-0.4.0/tests/test_react_schedule_run_tool.py

@@ -0,0 +1,99 @@
+"""The `schedule_run` builtin (framework backlog 1045): a ReAct call becomes ONE `SCHEDULE_RUN` effect
+with at most the agent's tools and never `schedule_run` itself; the host creates the wake."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import pytest
+
+from abstractagent.adapters.react_runtime import create_react_workflow
+from abstractagent.logic.builtins import SCHEDULE_RUN_TOOL
+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.scheduler.registry import WorkflowRegistry
+from abstractruntime.storage.in_memory import InMemoryLedgerStore, InMemoryRunStore
+
+
+def _run(arguments: Dict[str, Any], *, allowed_tools: List[str], handler: Any) -> RunState:
+    calls: Dict[str, int] = {}
+
+    def llm_handler(run: RunState, effect: Effect, default_next_node: Optional[str]) -> EffectOutcome:
+        calls[run.run_id] = calls.get(run.run_id, 0) + 1
+        if calls[run.run_id] == 1:
+            return EffectOutcome.completed({"content": "Scheduling.", "finish_reason": "tool_calls",
+                                            "tool_calls": [{"name": "schedule_run", "arguments": arguments, "call_id": "call_1"}]})
+        return EffectOutcome.completed({"content": "Done.", "tool_calls": [], "finish_reason": "stop"})
+
+    runtime = Runtime(run_store=InMemoryRunStore(), ledger_store=InMemoryLedgerStore(),
+                      effect_handlers={EffectType.LLM_CALL: llm_handler}, workflow_registry=WorkflowRegistry())
+    runtime.set_schedule_run_handler(handler)
+    tool_defs = [SCHEDULE_RUN_TOOL, ToolDefinition(name="read_file", description="Read", parameters={}),
+                 ToolDefinition(name="execute_command", description="Run", parameters={})]
+    workflow = create_react_workflow(logic=ReActLogic(tools=tool_defs), workflow_id="react_agent")
+    runtime.workflow_registry.register(workflow)
+    run_id = runtime.start(workflow=workflow, session_id="chat-S",
+                           vars={"context": {"task": "Remind me", "messages": []}, "_runtime": {"inbox": [], "allowed_tools": allowed_tools}})
+    for _ in range(200):
+        state = runtime.tick(workflow=workflow, run_id=run_id, max_steps=1)
+        if state.status in (RunStatus.COMPLETED, RunStatus.FAILED):
+            break
+    return runtime.get_state(run_id)
+
+
+def _tool_messages(final: RunState) -> List[str]:
+    msgs = (final.output or {}).get("messages") or []
+    return [str(m.get("content") or "") for m in msgs if isinstance(m, dict) and m.get("role") == "tool"]
+
+
+@pytest.mark.basic
+def test_schedule_run_passes_at_most_the_agents_tools_never_itself() -> None:
+    plans: List[Dict[str, Any]] = []
+
+    def host(run, plan):
+        plans.append(plan)
+        return {"automation_id": "auto-1"}
+
+    final = _run({"after_s": 300, "task": "check the build", "tools": ["read_file", "execute_command", "schedule_run"]},
+                 allowed_tools=["schedule_run", "read_file"], handler=host)
+    assert final.status == RunStatus.COMPLETED
+    (plan,) = plans
+    assert plan["allowed_tools"] == ["read_file"]  # execute_command is not the agent's; schedule_run never passes on
+    assert plan["session_id"] == "chat-S" and plan["mode"] == "same_session" and plan["kind"] == "task"
+    assert plan["input_data"]["_runtime"]["allowed_tools"] == ["read_file"]
+    assert any("auto-1" in m for m in _tool_messages(final))
+
+
+@pytest.mark.basic
+def test_schedule_run_inherits_the_agents_tools_when_omitted_and_a_note_gets_none() -> None:
+    plans: List[Dict[str, Any]] = []
+    final = _run({"after_s": 60, "note": "stretch"}, allowed_tools=["schedule_run", "read_file", "execute_command"],
+                 handler=lambda run, plan: plans.append(plan) or {"automation_id": "auto-2"})
+    assert final.status == RunStatus.COMPLETED
+    assert plans[0]["allowed_tools"] == [] and plans[0]["kind"] == "note"
+    plans.clear()
+    _run({"after_s": 60, "task": "t"}, allowed_tools=["schedule_run", "read_file", "execute_command"],
+         handler=lambda run, plan: plans.append(plan) or {"automation_id": "auto-3"})
+    assert plans[0]["allowed_tools"] == ["execute_command", "read_file"]
+
+
+@pytest.mark.basic
+def test_schedule_run_outside_the_allowlist_is_refused_without_calling_the_host() -> None:
+    plans: List[Dict[str, Any]] = []
+    final = _run({"after_s": 60, "note": "x"}, allowed_tools=["read_file"], handler=lambda run, plan: plans.append(plan) or {"automation_id": "x"})
+    assert final.status == RunStatus.COMPLETED
+    assert plans == []
+    assert any("schedule_run" in m for m in _tool_messages(final))
+
+
+@pytest.mark.basic
+def test_schedule_run_passes_notify_and_notes_notify_by_default() -> None:
+    plans: List[Dict[str, Any]] = []
+    host = lambda run, plan: plans.append(plan) or {"automation_id": "a"}  # noqa: E731
+    _run({"after_s": 60, "note": "drink water"}, allowed_tools=["schedule_run"], handler=host)
+    _run({"after_s": 60, "task": "t", "tools": []}, allowed_tools=["schedule_run"], handler=host)
+    _run({"after_s": 60, "task": "t", "tools": [], "notify": True}, allowed_tools=["schedule_run"], handler=host)
+    assert [p["notify"] for p in plans] == [True, False, True]
+    assert plans[0]["notify_title"] == "drink water"

abstractagent-0.4.0/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

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

@@ -1,16 +0,0 @@
-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