agentropic 0.4.0__tar.gz → 0.4.2__tar.gz

{agentropic-0.4.0 → agentropic-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentropic
-Version: 0.4.0
+Version: 0.4.2
 Summary: A minimal, hackable agentic framework: LLM calls via litellm, @tool-decorated functions, and MCP server support.
 Author-email: Vishal Tiwari <vishaltiwari.up2019@gmail.com>
 License: MIT

{agentropic-0.4.0 → agentropic-0.4.2}/examples/hitl_agent.py

@@ -61,4 +61,4 @@ async def mode_b_pause_resume():
 
 if __name__ == "__main__":
     asyncio.run(mode_a_inline())
-    asyncio.run(mode_b_pause_resume())
+    # asyncio.run(mode_b_pause_resume())

{agentropic-0.4.0 → agentropic-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentropic"
-version = "0.4.0"
+version = "0.4.2"
 description = "A minimal, hackable agentic framework: LLM calls via litellm, @tool-decorated functions, and MCP server support."
 readme = "README.md"
 requires-python = ">=3.9"

{agentropic-0.4.0 → agentropic-0.4.2}/src/agentropic/agent.py

@@ -38,12 +38,14 @@ from contextlib import AsyncExitStack
 from dataclasses import asdict, dataclass, field
 
 from .hitl import (
+    APPROVAL_SYSTEM_NOTE,
     CANCELLED_MESSAGE,
-    DEFAULT_DENIAL_MESSAGE,
     ApprovalDecision,
     ApprovalHandler,
     ApprovalRequest,
     RunState,
+    denial_message,
+    denial_reminder,
     evaluate_policy,
 )
 from .llm import LLMClient, LLMResponse
@@ -197,6 +199,7 @@ class _RunCtx:
     decisions: dict[str, ApprovalDecision] = field(default_factory=dict)
     sticky: dict[str, bool] = field(default_factory=dict)
     pending: list[ApprovalRequest] = field(default_factory=list)
+    denied_notes: list[str] = field(default_factory=list)  # "name(args)" of calls a human denied
     run_id: str = field(default_factory=lambda: uuid.uuid4().hex)
 
 
@@ -303,8 +306,14 @@ class Agent:
 
     # -- message building --------------------------------------------------
 
+    def _uses_approvals(self) -> bool:
+        return any(tl.requires_approval for tl in self.registry.list())
+
     def _build_messages(self, user_input: str) -> list[dict]:
-        messages = [{"role": "system", "content": self.instructions}]
+        system = self.instructions
+        if self._uses_approvals():
+            system = f"{system}\n\n{APPROVAL_SYSTEM_NOTE}"
+        messages = [{"role": "system", "content": system}]
         messages.extend(self.memory.get())
         messages.append({"role": "user", "content": user_input})
         return messages
@@ -421,10 +430,8 @@ class Agent:
                     edited=decision.override_args is not None, auto=auto,
                 )
                 if not decision.approved:
-                    content = (
-                        f"Tool call denied by user: {decision.message}"
-                        if decision.message else DEFAULT_DENIAL_MESSAGE
-                    )
+                    content = denial_message(name, decision.message)
+                    ctx.denied_notes.append(f"{name}({json.dumps(args, default=str)})")
                     record = ToolCallRecord(
                         id=call_id, name=name, arguments=args, result=content,
                         error=True, iteration=iteration, status="denied",
@@ -443,6 +450,10 @@ class Agent:
                     tool_call=ToolCallRecord(id=call_id, name=name, arguments=args, iteration=iteration),
                 )
             tool_msg, record = await self._execute_tool(call_id, name, args, iteration)
+            if decision is not None and decision.approved and not record.error:
+                # Tell the model approval was granted, so it doesn't report
+                # the action as "still needing approval".
+                tool_msg["content"] = f"[Approved by the user and executed] {tool_msg['content']}"
             self._record_tool_result(ctx, tool_msg, record)
             if stream:
                 yield StreamEvent(type="tool_result", iteration=iteration, tool_call=record)
@@ -560,9 +571,19 @@ class Agent:
             for iteration in range(first_iteration, self.max_iterations + 1):
                 self.tracer.iteration_start(iteration, self.max_iterations)
                 llm_started = time.monotonic()
+                # If a human denied any call in this run, put an explicit
+                # reminder right next to where the model writes its answer.
+                # Small models otherwise ignore the DENIED tool result and
+                # summarise the original request as if everything ran.
+                # Transient: sent with this request only, never stored.
+                request_messages = ctx.messages
+                if ctx.denied_notes:
+                    request_messages = ctx.messages + [
+                        {"role": "user", "content": denial_reminder(ctx.denied_notes)}
+                    ]
                 if stream:
                     response = None
-                    async for item in self.llm.astream_response(ctx.messages, tools=tools_schema):
+                    async for item in self.llm.astream_response(request_messages, tools=tools_schema):
                         if isinstance(item, str):
                             self.tracer.stream_text(item)
                             yield StreamEvent(type="text", iteration=iteration, text=item)
@@ -570,7 +591,7 @@ class Agent:
                             response = item
                     assert response is not None
                 else:
-                    response = await self.llm.acomplete(ctx.messages, tools=tools_schema)
+                    response = await self.llm.acomplete(request_messages, tools=tools_schema)
                 ctx.raw_responses.append(response)
                 self.tracer.llm_response(
                     response.content or "",
@@ -613,6 +634,7 @@ class Agent:
                 self.tracer.final_answer(
                     result.output, result.iterations, len(result.tool_calls),
                     result.duration_seconds, result.usage, streamed=stream,
+                    denied=[tc.name for tc in result.tool_calls if tc.status == "denied"],
                 )
                 yield StreamEvent(type="done", iteration=iteration, result=result)
                 return

{agentropic-0.4.0 → agentropic-0.4.2}/src/agentropic/hitl.py

@@ -39,8 +39,46 @@ STATE_VERSION = 1
 # (sync or async). Used on @tool(requires_approval=...).
 ApprovalPolicy = t.Union[bool, t.Callable[[dict], t.Union[bool, t.Awaitable[bool]]]]
 
-DEFAULT_DENIAL_MESSAGE = "The user denied this tool call."
-CANCELLED_MESSAGE = "Tool call cancelled: the user moved on without approving it."
+CANCELLED_MESSAGE = (
+    "CANCELLED: this tool call was NOT executed because the user moved on "
+    "without approving it. The action did not happen."
+)
+
+# Added to the system prompt when any tool needs approval, so the model
+# knows how to treat denials instead of reporting success.
+APPROVAL_SYSTEM_NOTE = (
+    "Some tools require human approval before they run. If a tool result "
+    "starts with 'DENIED' or 'CANCELLED', that action was NOT performed: never "
+    "say or imply it was done. Tell the user clearly which actions were not "
+    "carried out and why, and do not retry the same call unless the user asks."
+)
+
+
+def denial_message(tool_name: str, reason: t.Optional[str] = None) -> str:
+    """The tool result the model sees when a human rejects a call. Worded
+    bluntly on purpose: softer phrasing gets ignored by smaller models,
+    which then claim the action succeeded."""
+    msg = (
+        f"DENIED: the user rejected this call to '{tool_name}'. "
+        f"The action was NOT performed and nothing was changed."
+    )
+    if reason:
+        msg += f" Reason given by the user: {reason}"
+    return msg
+
+
+def denial_reminder(denied_calls: list[str]) -> str:
+    """Transient note sent just before the model writes its next reply, so
+    it can't overlook denials. Not stored in memory or RunState."""
+    items = "\n".join(f"- {c}" for c in denied_calls)
+    return (
+        "[Automated notice from the agent runtime, not written by the user]\n"
+        "The user DENIED the following tool calls. They were NOT executed and "
+        "had NO effect:\n"
+        f"{items}\n"
+        "In your reply, state plainly that these actions were not performed. "
+        "Do not say or imply they were done, and do not retry them."
+    )
 
 
 @dataclass

{agentropic-0.4.0 → agentropic-0.4.2}/src/agentropic/tracing.py

@@ -323,14 +323,22 @@ class AgentTracer:
         duration: float,
         usage: dict,
         streamed: bool = False,
+        denied: t.Optional[list] = None,
     ) -> None:
+        """`denied` = names of tool calls a human rejected during this run."""
+        executed = tool_call_count - len(denied or [])
         stats = (
             f"{self._c(C.DIM)}⏱ {duration:.2f}s   🔁 {iterations} iteration(s)   "
-            f"🔧 {tool_call_count} tool call(s)"
+            f"🔧 {executed} tool call(s) run"
         )
         if usage and usage.get("total_tokens"):
             stats += f"   🎫 {usage['total_tokens']} tokens"
         stats += self._c(C.RESET)
+        if denied:
+            stats += (
+                f"\n{self._c(C.RED)}🚫 {len(denied)} denied (not executed): "
+                f"{', '.join(denied)}{self._c(C.RESET)}"
+            )
         self._print()
         # When streamed, the answer was already printed live above.
         lines = [stats] if streamed else [output, "", stats]

{agentropic-0.4.0 → agentropic-0.4.2}/tests/test_hitl.py

@@ -125,6 +125,49 @@ async def test_handler_denies_with_message(monkeypatch):
     assert "too risky" in tool_msgs[0]["content"]
 
 
+@pytest.mark.asyncio
+async def test_denial_is_explicit_and_system_prompt_explains_it(monkeypatch):
+    _script(monkeypatch, [DELETE, DONE])
+    result = await _agent(approval_handler=lambda req: False).arun("delete it")
+    tool_msg = next(m for m in result.messages if m["role"] == "tool")
+    assert tool_msg["content"].startswith("DENIED")
+    assert "NOT performed" in tool_msg["content"]
+    assert "DENIED" in result.messages[0]["content"]  # system note added
+
+
+@pytest.mark.asyncio
+async def test_denial_reminder_sent_to_model_but_not_stored(monkeypatch):
+    sent = []
+    turns = [DELETE, DONE]
+
+    async def acompletion(**kwargs):
+        sent.append(list(kwargs["messages"]))
+        kind, payload = turns[len(sent) - 1]
+        if kind == "tools":
+            return _full(tool_calls=[_tc(*x) for x in payload], finish="tool_calls")
+        return _full(content=payload)
+
+    monkeypatch.setattr(llm_mod.litellm, "acompletion", acompletion)
+    agent = _agent(approval_handler=lambda req: False)
+    result = await agent.arun("delete it")
+
+    last_request = sent[-1][-1]
+    assert last_request["role"] == "user"
+    assert "NOT executed" in last_request["content"]
+    assert "delete_file" in last_request["content"]
+    # transient: not in the run's messages or the agent's memory
+    assert all("Automated notice" not in str(m.get("content")) for m in result.messages)
+    assert all("Automated notice" not in str(m.get("content")) for m in agent.memory.get())
+
+
+@pytest.mark.asyncio
+async def test_approved_result_is_tagged(monkeypatch):
+    _script(monkeypatch, [DELETE, DONE])
+    result = await _agent(approval_handler=lambda req: True).arun("delete it")
+    tool_msg = next(m for m in result.messages if m["role"] == "tool")
+    assert tool_msg["content"].startswith("[Approved by the user and executed]")
+
+
 @pytest.mark.asyncio
 async def test_async_handler_with_override_args(monkeypatch):
     _script(monkeypatch, [DELETE, DONE])

agentropic-0.4.0/tests/test_agent.py

@@ -1,40 +0,0 @@
-import pytest
-
-from agentropic.tools import tool, ToolRegistry, Tool
-
-
-def test_tool_decorator_builds_schema():
-    @tool()
-    def greet(name: str, excited: bool = False) -> str:
-        """Say hello to someone."""
-        return f"Hello {name}!" + ("!!!" if excited else "")
-
-    built: Tool = greet._tool
-    assert built.name == "greet"
-    assert "name" in built.parameters["properties"]
-    assert "name" in built.parameters["required"]
-    assert "excited" not in built.parameters["required"]
-    assert built.call(name="Ada") == "Hello Ada!"
-
-
-def test_registry_openai_schema():
-    @tool()
-    def noop() -> str:
-        """Does nothing."""
-        return "ok"
-
-    registry = ToolRegistry([noop])
-    schema = registry.to_openai_tools()
-    assert schema[0]["function"]["name"] == "noop"
-    assert registry.get("noop") is not None
-
-
-@pytest.mark.asyncio
-async def test_async_tool_call():
-    @tool()
-    async def slow_add(a: int, b: int) -> int:
-        """Add two numbers asynchronously."""
-        return a + b
-
-    result = await slow_add._tool.acall(a=2, b=3)
-    assert result == 5

agentropic-0.4.0/tests/test_streaming.py

@@ -1,124 +0,0 @@
-"""Streaming + tool-call loop tests using a fake LLM (no API key needed)."""
-import types
-
-import pytest
-
-from agentropic import Agent, StreamEvent, tool
-from agentropic import llm as llm_mod
-
-
-# -- fake litellm ---------------------------------------------------------------
-
-def _ns(**kw):
-    return types.SimpleNamespace(**kw)
-
-
-def _tool_call(id_, name, args):
-    return _ns(id=id_, function=_ns(name=name, arguments=args))
-
-
-def _full_response(content=None, tool_calls=None, finish="stop"):
-    return _ns(
-        choices=[_ns(message=_ns(content=content, tool_calls=tool_calls), finish_reason=finish)],
-        usage=_ns(prompt_tokens=1, completion_tokens=1, total_tokens=2),
-    )
-
-
-class _FakeStream:
-    def __init__(self, chunks):
-        self._chunks = list(chunks)
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        if not self._chunks:
-            raise StopAsyncIteration
-        return self._chunks.pop(0)
-
-
-def _install_fake_llm(monkeypatch):
-    """Turn 1: model calls get_weather. Turn 2: model answers in 3 tokens."""
-    calls = {"n": 0}
-
-    async def acompletion(**kwargs):
-        calls["n"] += 1
-        first = calls["n"] == 1
-        if kwargs.get("stream"):
-            if first:
-                chunk = _ns(choices=[_ns(delta=_ns(content=None))], _final=_full_response(
-                    tool_calls=[_tool_call("c1", "get_weather", '{"city": "Tokyo"}')], finish="tool_calls"))
-                return _FakeStream([chunk])
-            tokens = ["It's ", "sunny ", "in Tokyo."]
-            chunks = [_ns(choices=[_ns(delta=_ns(content=tok))]) for tok in tokens]
-            chunks[-1]._final = _full_response(content="".join(tokens))
-            return _FakeStream(chunks)
-        if first:
-            return _full_response(tool_calls=[_tool_call("c1", "get_weather", '{"city": "Tokyo"}')], finish="tool_calls")
-        return _full_response(content="It's sunny in Tokyo.")
-
-    def stream_chunk_builder(chunks, messages=None):
-        return chunks[-1]._final
-
-    monkeypatch.setattr(llm_mod.litellm, "acompletion", acompletion)
-    monkeypatch.setattr(llm_mod.litellm, "stream_chunk_builder", stream_chunk_builder)
-    return calls
-
-
-@tool()
-def get_weather(city: str) -> str:
-    """Get the weather."""
-    return f"sunny in {city}"
-
-
-def _agent():
-    return Agent(name="t", model="fake/model", tools=[get_weather])
-
-
-# -- tests ---------------------------------------------------------------------
-
-@pytest.mark.asyncio
-async def test_arun_non_streaming_with_tools(monkeypatch):
-    _install_fake_llm(monkeypatch)
-    result = await _agent().arun("weather?")
-    assert result == "It's sunny in Tokyo."
-    assert result.tool_calls[0].name == "get_weather"
-    assert result.tool_calls[0].result == "sunny in Tokyo"
-    assert result.iterations == 2
-
-
-@pytest.mark.asyncio
-async def test_arun_stream_true_yields_events_and_runs_tools(monkeypatch):
-    _install_fake_llm(monkeypatch)
-    events: list[StreamEvent] = []
-    async for ev in await _agent().arun("weather?", stream=True):
-        events.append(ev)
-
-    types_seen = [e.type for e in events]
-    assert types_seen == ["tool_call", "tool_result", "text", "text", "text", "done"]
-    assert events[0].tool_call.arguments == {"city": "Tokyo"}
-    assert events[1].tool_call.result == "sunny in Tokyo"
-    assert "".join(e.text for e in events if e.type == "text") == "It's sunny in Tokyo."
-    assert events[-1].result.output == "It's sunny in Tokyo."
-
-
-@pytest.mark.asyncio
-async def test_astream_text_only(monkeypatch):
-    _install_fake_llm(monkeypatch)
-    text = "".join([tok async for tok in _agent().astream("weather?")])
-    assert text == "It's sunny in Tokyo."
-
-
-def test_sync_run_stream(monkeypatch):
-    _install_fake_llm(monkeypatch)
-    events = list(_agent().run("weather?", stream=True))
-    assert events[-1].type == "done"
-    assert events[-1].result.output == "It's sunny in Tokyo."
-
-
-def test_result_is_json_serializable(monkeypatch):
-    import json
-
-    _install_fake_llm(monkeypatch)
-    result = _agent().run("weather?")
-    json.dumps(result.to_dict())  # tool_calls are plain dicts now