reflex-agentkit 0.1.0__tar.gz → 0.2.0__tar.gz

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-31
+
+### Added
+
+- The documentation site is published to GitHub Pages from `main`
+  (<https://blog.seraph.to/reflex-agentkit/>).
+- The model is told when the user approves a tool call with edited arguments (REQ-035).
+  Without this, models tended to report the edited result as a mistake or call the tool
+  again with their own arguments.
+  - `PydanticAIAgent` appends a notice to the edited call's result. Turn it off with
+    `notify_edited_args=False`.
+  - For LangGraph, `ApprovalDecision` gains `edited` and `tool_result(result)`. Build the
+    `ToolMessage` from `decision.tool_result(...)`.
+
+### Changed
+
+- Approving with "edited" arguments identical to the proposed ones now records a plain
+  approval, without `editedArgs` (REQ-013.3).
+- `astral-sh/setup-uv` is pinned to a commit SHA in every workflow.
+- Markdown-image exfiltration is an accepted residual risk; markdown images stay
+  supported (TD v1.15).
+
 ## [0.1.0] - 2026-10-31
 
 The first release. `0.1.0rc1` was published on 2026-10-31 as its release candidate.
@@ -117,5 +139,6 @@ The first release. `0.1.0rc1` was published on 2026-10-31 as its release candida
 - The latest-dependencies workflow runs the newest, unvetted versions without a token or
   stored git credentials; a separate job reports failures.
 
-[Unreleased]: https://github.com/ecrespo/reflex-agentkit/compare/v0.1.0...HEAD
+[Unreleased]: https://github.com/ecrespo/reflex-agentkit/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/ecrespo/reflex-agentkit/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/ecrespo/reflex-agentkit/releases/tag/v0.1.0

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.5
 Name: reflex-agentkit
-Version: 0.1.0
+Version: 0.2.0
 Summary: The production UI layer for Python AI agents, built on Reflex and the AG-UI protocol.
 Project-URL: Homepage, https://github.com/ecrespo/reflex-agentkit
+Project-URL: Documentation, https://blog.seraph.to/reflex-agentkit/
 Project-URL: Repository, https://github.com/ecrespo/reflex-agentkit
 Project-URL: Issues, https://github.com/ecrespo/reflex-agentkit/issues
 Project-URL: Changelog, https://github.com/ecrespo/reflex-agentkit/blob/main/CHANGELOG.md
@@ -44,10 +45,11 @@ chat, tool-call cards and human-in-the-loop approval for LangGraph, PydanticAI a
 AG-UI-compatible agent. The production UI layer your agent was missing — no TypeScript,
 no Streamlit.
 
-> **Status: `0.1.0`, the first release.** Everything in v0.1 is implemented and tested: the pure core,
+> **Status: `0.2.0`.** Everything in v0.1 is implemented and tested: the pure core,
 > the agent clients, the Reflex state engine (`AgentState`), the chat components, both
-> adapters (PydanticAI and LangGraph) and the AG-UI Dojo examples.
-> `pip install "reflex-agentkit[pydantic-ai]"` or `uv add "reflex-agentkit[pydantic-ai]"`. Documentation: [`docs/`](docs/) (`uv run mkdocs serve`).
+> adapters (PydanticAI and LangGraph) and the AG-UI Dojo examples. `0.2.0` tells the model
+> when the user edits a tool call's arguments before approving it.
+> `pip install "reflex-agentkit[pydantic-ai]"` or `uv add "reflex-agentkit[pydantic-ai]"`. Documentation: https://blog.seraph.to/reflex-agentkit/
 
 ## Why
 
@@ -161,7 +163,8 @@ an accessible label.
 
 The MkDocs site in [`docs/`](docs/) covers getting started (uv and pip), the concepts,
 guides (your own UI, human in the loop, sidecar deployment, local models with Ollama), the
-API reference, the security model and troubleshooting. Preview it with
+API reference, the security model and troubleshooting. It is published at
+<https://blog.seraph.to/reflex-agentkit/> from `main`; preview it locally with
 `uv run mkdocs serve`.
 
 ## Progress
@@ -180,6 +183,7 @@ Work follows the approved spec chain in [`specs/`](specs/) and the task list in
 | WP6 — LangGraph adapter | `LangGraphAGUIAgent`, `request_tool_approval`, legacy interrupts | ✅ done |
 | WP7 — Dojo examples | The five AG-UI Dojo demos for PydanticAI and LangGraph | ✅ done |
 | WP8 — Hardening, docs, release | Security review, benchmarks, documentation site, `0.1.0` on PyPI | ✅ done |
+| Change: edited-args notice | REQ-035: the model learns about edited tool arguments (`changes/_archive/`) | ✅ `0.2.0` |
 
 ## What works today: `reflex_agentkit.core`
 
@@ -333,7 +337,8 @@ app.add_page(index)
 
 Install the extra (`reflex-agentkit[pydantic-ai]`) and wrap the agent. Tools declared with
 `requires_approval=True` pause the run for `approve_tool` / `reject_tool` with no extra
-configuration; edited arguments reach the tool.
+configuration; edited arguments reach the tool, and the tool's result tells the model the
+user changed them (`notify_edited_args=False` turns that off).
 
 ```python
 from typing import ClassVar
@@ -383,6 +388,7 @@ def tools(state: MessagesState) -> dict[str, Any]:
     call = last.tool_calls[0]
     decision = request_tool_approval(str(call["id"]), call["name"], call["args"])
     content = f"Booked {decision.args['city']}" if decision.approved else "Not booked"
+    content = decision.tool_result(content)  # tells the model about edited arguments
     return {"messages": [ToolMessage(content=content, tool_call_id=call["id"])]}
 
 

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/README.md

@@ -5,10 +5,11 @@ chat, tool-call cards and human-in-the-loop approval for LangGraph, PydanticAI a
 AG-UI-compatible agent. The production UI layer your agent was missing — no TypeScript,
 no Streamlit.
 
-> **Status: `0.1.0`, the first release.** Everything in v0.1 is implemented and tested: the pure core,
+> **Status: `0.2.0`.** Everything in v0.1 is implemented and tested: the pure core,
 > the agent clients, the Reflex state engine (`AgentState`), the chat components, both
-> adapters (PydanticAI and LangGraph) and the AG-UI Dojo examples.
-> `pip install "reflex-agentkit[pydantic-ai]"` or `uv add "reflex-agentkit[pydantic-ai]"`. Documentation: [`docs/`](docs/) (`uv run mkdocs serve`).
+> adapters (PydanticAI and LangGraph) and the AG-UI Dojo examples. `0.2.0` tells the model
+> when the user edits a tool call's arguments before approving it.
+> `pip install "reflex-agentkit[pydantic-ai]"` or `uv add "reflex-agentkit[pydantic-ai]"`. Documentation: https://blog.seraph.to/reflex-agentkit/
 
 ## Why
 
@@ -122,7 +123,8 @@ an accessible label.
 
 The MkDocs site in [`docs/`](docs/) covers getting started (uv and pip), the concepts,
 guides (your own UI, human in the loop, sidecar deployment, local models with Ollama), the
-API reference, the security model and troubleshooting. Preview it with
+API reference, the security model and troubleshooting. It is published at
+<https://blog.seraph.to/reflex-agentkit/> from `main`; preview it locally with
 `uv run mkdocs serve`.
 
 ## Progress
@@ -141,6 +143,7 @@ Work follows the approved spec chain in [`specs/`](specs/) and the task list in
 | WP6 — LangGraph adapter | `LangGraphAGUIAgent`, `request_tool_approval`, legacy interrupts | ✅ done |
 | WP7 — Dojo examples | The five AG-UI Dojo demos for PydanticAI and LangGraph | ✅ done |
 | WP8 — Hardening, docs, release | Security review, benchmarks, documentation site, `0.1.0` on PyPI | ✅ done |
+| Change: edited-args notice | REQ-035: the model learns about edited tool arguments (`changes/_archive/`) | ✅ `0.2.0` |
 
 ## What works today: `reflex_agentkit.core`
 
@@ -294,7 +297,8 @@ app.add_page(index)
 
 Install the extra (`reflex-agentkit[pydantic-ai]`) and wrap the agent. Tools declared with
 `requires_approval=True` pause the run for `approve_tool` / `reject_tool` with no extra
-configuration; edited arguments reach the tool.
+configuration; edited arguments reach the tool, and the tool's result tells the model the
+user changed them (`notify_edited_args=False` turns that off).
 
 ```python
 from typing import ClassVar
@@ -344,6 +348,7 @@ def tools(state: MessagesState) -> dict[str, Any]:
     call = last.tool_calls[0]
     decision = request_tool_approval(str(call["id"]), call["name"], call["args"])
     content = f"Booked {decision.args['city']}" if decision.approved else "Not booked"
+    content = decision.tool_result(content)  # tells the model about edited arguments
     return {"messages": [ToolMessage(content=content, tool_call_id=call["id"])]}
 
 

reflex_agentkit-0.2.0/changes/README.md

@@ -0,0 +1,11 @@
+# Changes
+
+Proposals that change the observable behavior or the public API of a released
+reflex-agentkit (CLAUDE.md, spec-anchored process). Each change lives in
+`changes/<yyyy-mm>-<slug>/` with `proposal.md`, `delta-spec.md` and `tasks.md`. Once the
+maintainer approves it and it ships, the delta is folded into `specs/` in the same PR and
+the folder moves to `changes/_archive/`.
+
+| Change | Status |
+|---|---|
+| [`2026-11-edited-args-notice`](_archive/2026-11-edited-args-notice/proposal.md) | Released in `0.2.0`, folded into `specs/`, archived |

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/pyproject.toml

@@ -36,6 +36,7 @@ all = ["reflex-agentkit[pydantic-ai,langgraph]"]
 
 [project.urls]
 Homepage = "https://github.com/ecrespo/reflex-agentkit"
+Documentation = "https://blog.seraph.to/reflex-agentkit/"
 Repository = "https://github.com/ecrespo/reflex-agentkit"
 Issues = "https://github.com/ecrespo/reflex-agentkit/issues"
 Changelog = "https://github.com/ecrespo/reflex-agentkit/blob/main/CHANGELOG.md"

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/src/reflex_agentkit/__init__.py

@@ -29,7 +29,7 @@ if TYPE_CHECKING:  # type checkers see the lazy names; runtime imports them on f
     from reflex_agentkit.components.chat import agent_chat as agent_chat
     from reflex_agentkit.state.agent_state import AgentState as AgentState
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 
 # Public name -> module that defines it (API §1, §3).
 _LAZY_EXPORTS: dict[str, str] = {

reflex_agentkit-0.2.0/src/reflex_agentkit/adapters/_edits.py

@@ -0,0 +1,35 @@
+"""The edited-arguments notice both adapters give the model (REQ-035, DD-016).
+
+When the user approves a tool call with edited arguments, the model only sees a result
+that does not match what it asked for, and may "correct" the user by calling the tool
+again. The notice tells it the edit was deliberate.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+import pydantic_core
+
+__all__ = ["EDITED_ARGS_NOTICE", "with_edited_args_notice"]
+
+EDITED_ARGS_NOTICE = (
+    "Note: the user edited this tool call's arguments before approving it, so the tool "
+    "ran with: {args}. These are the arguments the user wants: do not call the tool "
+    "again to restore the earlier ones, and do not report the change as an error."
+)
+"""Normative text (REQ-035); tests pin it, so a change here is a spec change."""
+
+
+def with_edited_args_notice(result: Any, args: Mapping[str, Any]) -> str:
+    """``result`` followed by a blank line and the notice naming ``args``.
+
+    A non-string result is serialized to JSON first, as PydanticAI does for tool returns.
+    """
+    text = (
+        result if isinstance(result, str) else pydantic_core.to_json(result, fallback=str).decode()
+    )
+    shown = json.dumps(dict(args), ensure_ascii=False, default=str)
+    return f"{text}\n\n{EDITED_ARGS_NOTICE.format(args=shown)}"

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/src/reflex_agentkit/adapters/langgraph.py

@@ -37,6 +37,7 @@ from langgraph.graph.state import CompiledStateGraph  # noqa: E402
 from langgraph.types import Command, interrupt  # noqa: E402
 from langgraph.types import Interrupt as LangGraphInterrupt  # noqa: E402
 
+from reflex_agentkit.adapters._edits import with_edited_args_notice  # noqa: E402
 from reflex_agentkit.core.errors import ConfigurationError  # noqa: E402
 
 __all__ = ["ApprovalDecision", "LangGraphAGUIAgent", "request_tool_approval"]
@@ -76,11 +77,26 @@ class ApprovalDecision:
             otherwise the original ones.
         reason: The rejection reason, ``"cancelled"`` when the run was cancelled while
             waiting, or ``None``.
+        edited: Whether the user approved with arguments that differ from the proposed
+            ones (REQ-035.2, REQ-035.5).
     """
 
     approved: bool
     args: dict[str, Any]
     reason: str | None = None
+    edited: bool = False
+
+    def tool_result(self, result: Any) -> Any:
+        """The result to give the model: with the edited-arguments notice when ``edited``.
+
+        Use it to build the ``ToolMessage`` so the model knows the user changed the
+        arguments on purpose (REQ-035.2). Without edits ``result`` comes back unchanged.
+        """
+        if not self.edited:
+            return result
+        text = with_edited_args_notice(result, self.args)
+        _log.debug("edited-arguments notice: %s", text)
+        return text
 
 
 def request_tool_approval(
@@ -120,9 +136,9 @@ def _decision(answer: Any, args: dict[str, Any]) -> ApprovalDecision:
     if answer.get("approved") is not True:
         return ApprovalDecision(approved=False, args=args, reason=reason)
     edited = answer.get("editedArgs")
-    return ApprovalDecision(
-        approved=True, args=dict(edited) if isinstance(edited, Mapping) else args
-    )
+    if not isinstance(edited, Mapping) or dict(edited) == args:
+        return ApprovalDecision(approved=True, args=args)
+    return ApprovalDecision(approved=True, args=dict(edited), edited=True)
 
 
 class LangGraphAGUIAgent(LangGraphAgent):  # type: ignore[misc]  # untyped upstream base

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/src/reflex_agentkit/adapters/pydantic_ai.py

@@ -6,21 +6,31 @@ from reflex_agentkit.adapters._require import require
 
 require("pydantic-ai", "pydantic_ai", "pydantic_ai.ui.ag_ui")
 
-import inspect  # noqa: E402 - the guard must run before the optional imports
-from collections.abc import AsyncIterator, Awaitable, Callable, Sequence  # noqa: E402
+import dataclasses  # noqa: E402 - the guard must run before the optional imports
+import inspect  # noqa: E402
+import logging  # noqa: E402
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, Sequence  # noqa: E402
 from typing import Any  # noqa: E402
 
 from ag_ui.core import BaseEvent, RunAgentInput  # noqa: E402
-from pydantic_ai import DeferredToolRequests  # noqa: E402
+from pydantic_ai import DeferredToolRequests, RunContext  # noqa: E402
 from pydantic_ai.agent import AbstractAgent  # noqa: E402
+from pydantic_ai.capabilities import AbstractCapability  # noqa: E402
+from pydantic_ai.exceptions import UserError  # noqa: E402
+from pydantic_ai.messages import ToolCallPart  # noqa: E402
+from pydantic_ai.tools import ToolDefinition  # noqa: E402
 from pydantic_ai.ui.ag_ui import AGUIAdapter  # noqa: E402
+from pydantic_ai.ui.ag_ui._interrupt import interrupt_id_to_tool_call_id  # noqa: E402
 
+from reflex_agentkit.adapters._edits import with_edited_args_notice  # noqa: E402
 from reflex_agentkit.core.errors import ConfigurationError  # noqa: E402
 
 __all__ = ["PydanticAIAgent"]
 
 DepsFactory = Callable[[RunAgentInput], Any | Awaitable[Any]]
 
+_log = logging.getLogger(__name__)
+
 
 class PydanticAIAgent:
     """Run a PydanticAI agent as an ``AGUIAgent`` (REQ-022.1).
@@ -34,6 +44,9 @@ class PydanticAIAgent:
         deps: Dependencies passed to every run.
         deps_factory: Builds the dependencies of one run from its input (sync or async).
             Mutually exclusive with ``deps``.
+        notify_edited_args: Tell the model when the user approved a tool call with
+            edited arguments, by appending a notice to the tool's result (REQ-035.1,
+            REQ-035.4).
         run_kwargs: Forwarded to ``AGUIAdapter.run_stream`` (``model_settings``,
             ``usage_limits``, ``model``, ...).
     """
@@ -44,6 +57,7 @@ class PydanticAIAgent:
         *,
         deps: Any = None,
         deps_factory: DepsFactory | None = None,
+        notify_edited_args: bool = True,
         **run_kwargs: Any,
     ) -> None:
         if not isinstance(agent, AbstractAgent):
@@ -56,6 +70,7 @@ class PydanticAIAgent:
         self._deps = deps
         self._deps_factory = deps_factory
         self._run_kwargs = run_kwargs
+        self._notify_edited_args = notify_edited_args
         self._output_type = _with_deferred(agent.output_type)
 
     def __repr__(self) -> str:
@@ -71,6 +86,9 @@ class PydanticAIAgent:
         kwargs = dict(self._run_kwargs)
         if self._output_type is not None:
             kwargs.setdefault("output_type", self._output_type)
+        edits = _edited_calls(run_input) if self._notify_edited_args else {}
+        if edits:
+            kwargs["capabilities"] = [*(kwargs.get("capabilities") or ()), _EditNotice(edits)]
         adapter = AGUIAdapter(agent=self._agent, run_input=run_input)
         stream = adapter.run_stream(deps=deps, **kwargs)
         try:
@@ -91,3 +109,44 @@ def _with_deferred(output_type: Any) -> list[Any] | None:
     if any(t is DeferredToolRequests for t in types):
         return None
     return [*types, DeferredToolRequests]
+
+
+def _edited_calls(run_input: RunAgentInput) -> dict[str, dict[str, Any]]:
+    """Tool call ID → edited arguments, for every approval resumed with ``editedArgs``."""
+    edits: dict[str, dict[str, Any]] = {}
+    for entry in run_input.resume or ():
+        payload = entry.payload
+        if entry.status != "resolved" or not isinstance(payload, Mapping):
+            continue
+        edited = payload.get("editedArgs")
+        if payload.get("approved") is not True or not isinstance(edited, Mapping):
+            continue
+        try:
+            call_id = interrupt_id_to_tool_call_id(entry.interrupt_id)
+        except UserError:  # not one of PydanticAI's approval interrupts
+            continue
+        edits[call_id] = dict(edited)
+    return edits
+
+
+@dataclasses.dataclass
+class _EditNotice(AbstractCapability[Any]):
+    """Append the edited-arguments notice to the results of edited calls (DD-016)."""
+
+    edits: dict[str, dict[str, Any]]
+
+    async def after_tool_execute(
+        self,
+        ctx: RunContext[Any],
+        *,
+        call: ToolCallPart,
+        tool_def: ToolDefinition,
+        args: Any,
+        result: Any,
+    ) -> Any:
+        edited = self.edits.get(call.tool_call_id)
+        if edited is None:
+            return result
+        text = with_edited_args_notice(result, edited)
+        _log.debug("edited-arguments notice: %s", text)
+        return text

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/src/reflex_agentkit/core/commands.py

@@ -121,7 +121,7 @@ def _with_call(conv: ConversationState, call: ToolCall) -> tuple[ToolCall, ...]:
 def apply_approval(
     conv: ConversationState, call_id: str, edited_args: object = None
 ) -> ConversationState:
-    """Approve a pending tool call, optionally with edited arguments (REQ-013.2-3, 013.7).
+    """Approve a pending tool call, optionally with edited arguments (REQ-013.2-3, 013.7, 035.5).
 
     A ``str`` ``edited_args`` is parsed as JSON. Edits that are not a JSON object or that
     exceed :data:`MAX_PAYLOAD_BYTES` serialized set ``INVALID_EDITED_ARGS`` and leave the
@@ -146,8 +146,9 @@ def apply_approval(
             return _invalid_edit(conv, "the edited arguments are not serializable as JSON")
         if too_large:
             return _invalid_edit(conv, f"the edited arguments exceed {MAX_PAYLOAD_BYTES} bytes")
-        args = edited_args
-        payload["editedArgs"] = edited_args
+        if edited_args != call.args:  # an unchanged "edit" is a plain approval (REQ-035.5)
+            args = edited_args
+            payload["editedArgs"] = edited_args
     running = replace(call, status=ToolCallStatus.RUNNING, args=args)
     answer = InterruptAnswer(interrupt_id=interrupt.id, status="resolved", payload=payload)
     return _record(conv, answer, tool_calls=_with_call(conv, running))

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/contract/test_pydantic_ai_facts.py

@@ -132,3 +132,17 @@ async def test_TD_8_4_2_frontend_tool_call_ends_with_success_not_interrupt() ->
     assert last.outcome is None or last.outcome.type == "success"
     pending = getattr(last.outcome, "pending_tool_call_ids", None)
     assert pending in (None, [starts[0].tool_call_id])
+
+
+def test_TD_DD_016_interrupt_ids_map_back_to_tool_call_ids() -> None:
+    """DD-016: the private helper the adapter uses to find the edited call still exists."""
+    from pydantic_ai.ui.ag_ui._interrupt import interrupt_id_to_tool_call_id
+
+    assert interrupt_id_to_tool_call_id("int-call_1") == "call_1"
+
+
+def test_TD_DD_016_run_stream_accepts_run_level_capabilities() -> None:
+    """DD-016: the notice rides on a per-run capability, merged with the agent's own."""
+    import inspect
+
+    assert "capabilities" in inspect.signature(AGUIAdapter.run_stream).parameters

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/integration/test_langgraph_hitl.py

@@ -128,14 +128,14 @@ async def _pause_for_approval(rx_: ReflexHarness, token: str) -> HotelGraphState
 async def test_REQ_034_3_approval_with_edits_reaches_the_tool(
     reflex_harness: ReflexHarness,
 ) -> None:
-    """REQ-034.3: the helper returns the decision, edited args included."""
+    """REQ-034.3, REQ-035.2: the helper returns the decision, edits flagged."""
     await _pause_for_approval(reflex_harness, "edit")
     await reflex_harness.call(
         "edit", HotelGraphState, "approve_tool", call_id="c1", edited_args={"city": "Porto"}
     )
     state = await reflex_harness.state("edit", HotelGraphState)
     assert state.run_status == RunStatus.IDLE, state.error
-    assert decisions == [ApprovalDecision(approved=True, args={"city": "Porto"})]
+    assert decisions == [ApprovalDecision(approved=True, args={"city": "Porto"}, edited=True)]
     call = next(c for c in state.tool_calls if c.id == "c1")
     assert call.status == ToolCallStatus.DONE
     assert call.result == "Booked Porto"

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/integration/test_pydantic_ai_hitl.py

@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import ClassVar
 
 import pytest
@@ -61,12 +62,19 @@ async def test_REQ_022_2_approve_runs_the_tool(reflex_harness: ReflexHarness) ->
     assert state.run_status == RunStatus.IDLE
     assert booked == ["a"]  # TestModel's generated argument
     call = state.tool_calls[0]
-    assert (call.status, call.result) == (ToolCallStatus.DONE, "booked a")
+    assert (call.status, call.result) == (ToolCallStatus.DONE, "booked a")  # REQ-035.3
     assert state.messages[-1].role == "assistant"
 
 
+NOTICE = (
+    "booked Porto\n\nNote: the user edited this tool call's arguments before approving it, "
+    'so the tool ran with: {"city": "Porto"}. These are the arguments the user wants: do not '
+    "call the tool again to restore the earlier ones, and do not report the change as an error."
+)
+
+
 async def test_REQ_022_3_approve_with_edited_args(reflex_harness: ReflexHarness) -> None:
-    """REQ-022.3: the tool receives the edited arguments."""
+    """REQ-022.3, REQ-035.1: the tool gets the edits and the model is told about them."""
     state = await _pause(reflex_harness, "edit")
     call_id = state.pending_approvals[0].id
     await reflex_harness.call(
@@ -74,10 +82,45 @@ async def test_REQ_022_3_approve_with_edited_args(reflex_harness: ReflexHarness)
     )
     state = await reflex_harness.state("edit", HotelState)
     assert booked == ["Porto"]
-    assert state.tool_calls[0].result == "booked Porto"
+    assert state.tool_calls[0].result == NOTICE
     assert state.run_status == RunStatus.IDLE
 
 
+class QuietHotelState(AgentState, rx.State):
+    agent: ClassVar = PydanticAIAgent(_hotel_agent(), notify_edited_args=False)
+
+
+async def test_REQ_035_4_notice_can_be_turned_off(reflex_harness: ReflexHarness) -> None:
+    """REQ-035.4: ``notify_edited_args=False`` leaves the tool result as the tool returned it."""
+    await reflex_harness.call("quiet", QuietHotelState, "send_message", text="book a hotel")
+    state = await reflex_harness.state("quiet", QuietHotelState)
+    call_id = state.pending_approvals[0].id
+    await reflex_harness.call(
+        "quiet", QuietHotelState, "approve_tool", call_id=call_id, edited_args={"city": "Porto"}
+    )
+    state = await reflex_harness.state("quiet", QuietHotelState)
+    assert booked == ["Porto"]
+    assert state.tool_calls[0].result == "booked Porto"
+
+
+async def test_REQ_035_6_notice_is_logged_only_at_debug(
+    reflex_harness: ReflexHarness, caplog: pytest.LogCaptureFixture
+) -> None:
+    """REQ-035.6: the notice holds user content, so nothing about it is logged above DEBUG."""
+    caplog.set_level(logging.DEBUG, logger="reflex_agentkit")
+    state = await _pause(reflex_harness, "log")
+    await reflex_harness.call(
+        "log",
+        HotelState,
+        "approve_tool",
+        call_id=state.pending_approvals[0].id,
+        edited_args={"city": "Porto"},
+    )
+    porto = [r for r in caplog.records if "Porto" in r.getMessage()]
+    assert porto, "the notice is logged at DEBUG"
+    assert all(r.levelno == logging.DEBUG for r in porto)
+
+
 async def test_REQ_022_2_reject_does_not_run_the_tool(reflex_harness: ReflexHarness) -> None:
     """REQ-022.2: rejection resumes without running the tool; the model sees the denial."""
     state = await _pause(reflex_harness, "reject")

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/test_smoke.py

@@ -9,7 +9,7 @@ def test_package_imports() -> None:
     """REQ-031.1: the package and its pure core import cleanly."""
     import reflex_agentkit.core
 
-    assert reflex_agentkit.__version__ == "0.1.0"
+    assert reflex_agentkit.__version__ == "0.2.0"
 
 
 def test_unknown_attribute_raises_attribute_error() -> None:

reflex_agentkit-0.2.0/tests/unit/adapters/test_edits.py

@@ -0,0 +1,44 @@
+"""The edited-arguments notice shared by both adapters (REQ-035, DD-016)."""
+
+from __future__ import annotations
+
+from reflex_agentkit.adapters._edits import EDITED_ARGS_NOTICE, with_edited_args_notice
+
+
+def test_REQ_035_1_notice_text_is_pinned() -> None:
+    """REQ-035: the normative notice; changing it changes what every model reads."""
+    assert EDITED_ARGS_NOTICE == (
+        "Note: the user edited this tool call's arguments before approving it, so the tool "
+        "ran with: {args}. These are the arguments the user wants: do not call the tool "
+        "again to restore the earlier ones, and do not report the change as an error."
+    )
+
+
+def test_REQ_035_1_string_results_get_the_notice_after_a_blank_line() -> None:
+    text = with_edited_args_notice("Booked 3 nights in Porto.", {"nights": 3, "city": "Porto"})
+    assert text == (
+        "Booked 3 nights in Porto.\n\nNote: the user edited this tool call's arguments "
+        'before approving it, so the tool ran with: {"nights": 3, "city": "Porto"}. '
+        "These are the arguments the user wants: do not call the tool again to restore the "
+        "earlier ones, and do not report the change as an error."
+    )
+
+
+def test_REQ_035_1_other_results_are_serialized_as_json_first() -> None:
+    """Non-string results are serialized the way PydanticAI serializes tool returns."""
+    text = with_edited_args_notice({"booked": True, "city": "Porto"}, {"city": "Porto"})
+    assert text.startswith('{"booked":true,"city":"Porto"}\n\nNote: ')
+
+
+def test_REQ_035_1_non_json_values_fall_back_to_str() -> None:
+    class Ticket:
+        def __str__(self) -> str:
+            return "ticket-7"
+
+    text = with_edited_args_notice(Ticket(), {"when": Ticket()})
+    assert text.startswith('"ticket-7"\n\nNote: ')
+    assert 'the tool ran with: {"when": "ticket-7"}. ' in text
+
+
+def test_REQ_035_1_unicode_stays_readable() -> None:
+    assert '{"city": "Málaga"}' in with_edited_args_notice("ok", {"city": "Málaga"})

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/unit/adapters/test_langgraph_resume.py

@@ -125,7 +125,39 @@ def test_REQ_034_3_approved_returns_the_original_args(fake: FakeInterrupt) -> No
 
 def test_REQ_034_3_edited_args_take_precedence(fake: FakeInterrupt) -> None:
     decision = _approve(fake, {"approved": True, "editedArgs": {"city": "Porto", "nights": 3}})
-    assert decision == ApprovalDecision(approved=True, args={"city": "Porto", "nights": 3})
+    assert decision == ApprovalDecision(
+        approved=True, args={"city": "Porto", "nights": 3}, edited=True
+    )
+
+
+def test_REQ_035_2_tool_result_appends_the_notice_when_edited(fake: FakeInterrupt) -> None:
+    """REQ-035.2: an edited approval's result carries the edited-arguments notice."""
+    decision = _approve(fake, {"approved": True, "editedArgs": {"city": "Porto", "nights": 3}})
+    assert decision.tool_result("Booked.") == (
+        "Booked.\n\nNote: the user edited this tool call's arguments before approving it, "
+        'so the tool ran with: {"city": "Porto", "nights": 3}. These are the arguments the '
+        "user wants: do not call the tool again to restore the earlier ones, and do not "
+        "report the change as an error."
+    )
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {"approved": True},
+        {"approved": True, "editedArgs": dict(ARGS)},
+        {"approved": False, "reason": "no"},
+    ],
+    ids=["plain", "unchanged-edit", "rejected"],
+)
+def test_REQ_035_3_tool_result_is_unchanged_without_edits(
+    fake: FakeInterrupt, payload: Any
+) -> None:
+    """REQ-035.3, REQ-035.5: no notice without a real edit, nor on rejection."""
+    decision = _approve(fake, payload)
+    assert decision.edited is False
+    assert decision.tool_result("Booked.") == "Booked."
+    assert decision.tool_result({"ok": 1}) == {"ok": 1}
 
 
 def test_REQ_034_3_rejection_carries_the_reason(fake: FakeInterrupt) -> None:

{reflex_agentkit-0.1.0 → reflex_agentkit-0.2.0}/tests/unit/core/test_commands.py

@@ -205,6 +205,15 @@ def test_REQ_013_3_approve_with_edited_args_records_payload(edited: object) -> N
     assert conv.tool_calls[0].args == {"city": "Porto"}
 
 
+@pytest.mark.parametrize("edited", [{"city": "Lisbon"}, '{"city": "Lisbon"}'], ids=["dict", "str"])
+def test_REQ_035_5_unchanged_edits_record_a_plain_approval(edited: object) -> None:
+    """REQ-035.5: edits equal to the current args are a plain approval, without ``editedArgs``."""
+    conv = apply_approval(_paused(_approval(), calls=(_pending_call(),)), "c1", edited)
+    assert conv.answers["int-c1"].payload == {"approved": True}
+    assert conv.tool_calls[0].args == {"city": "Lisbon"}
+    check_invariants(conv)
+
+
 @pytest.mark.parametrize(
     "edited",
     [[1, 2], "not json", '"a string"', {"big": "x" * MAX_PAYLOAD_BYTES}],