nodloop 0.6.6__tar.gz → 0.7.0__tar.gz

nodloop-0.7.0/PKG-INFO

@@ -0,0 +1,104 @@
+Metadata-Version: 2.5
+Name: nodloop
+Version: 0.7.0
+Summary: Record AI runs and the verdicts people give on them, and hand the knowledge they approve to the next run in the same place
+Project-URL: Homepage, https://github.com/jeon-jihyeon/nodloop
+Project-URL: Repository, https://github.com/jeon-jihyeon/nodloop
+License-Expression: MIT
+Keywords: agents,ai,feedback,human-in-the-loop,langchain,mcp,memory
+Requires-Python: >=3.10
+Requires-Dist: mcp>=2.0
+Provides-Extra: claude-agent
+Requires-Dist: claude-agent-sdk>=0.1; extra == 'claude-agent'
+Provides-Extra: langchain
+Requires-Dist: langchain>=1.0; extra == 'langchain'
+Provides-Extra: openai-agents
+Requires-Dist: openai-agents>=0.3.3; extra == 'openai-agents'
+Description-Content-Type: text/markdown
+
+# nodloop for Python
+
+Record what your agent answered, take a person's verdict on it, and hand the corrections they approve to the agent's next run in the same situation. This is the Python client of [nodloop](https://github.com/jeon-jihyeon/nodloop).
+
+```
+pip install nodloop
+pip install "nodloop[langchain]"      # or openai-agents, claude-agent
+```
+
+The client starts a local `nodloop mcp` over stdio, so no server runs. It uses `NODLOOP_BIN`, then the binary the Claude Code plugin keeps under `~/.nodloop/bin`, then `nodloop` on PATH, and otherwise downloads the release of its own version from GitHub and checks it against the release checksums. It requires Python 3.10 or newer and is tested on Linux with Python 3.12.
+
+## The loop
+
+```python
+from nodloop import Client
+
+acme = {"tenant": ["acme"], "task": ["refund"]}
+
+async with Client() as c:
+    knowledge = await c.knowledge("support-bot", acme)
+    prompt = f"{system_prompt}\n\n{knowledge.text}"  # empty text when nothing is approved
+    answer = await my_agent(prompt)
+    run = await c.record("support-bot", answer, labels=acme, applied=knowledge.items)
+
+    # later, when a person reads the answer
+    await c.judge(run, "reject", reason="the refund window was missing", reason_code="scope")
+    candidate = await c.propose("judgment", "Quote the refund window before the steps", from_run=run)
+    approval = await c.approve(candidate.id, candidate.version, approver="ann")
+```
+
+From then on every `knowledge("support-bot", acme)` carries the item, and a run of another tenant never does. `judge` takes `approve`, `edit` with `edited=` holding the corrected output, `reject` with what was wrong, or `withdraw` to take back the verdict before it.
+
+| Method | Returns |
+|---|---|
+| `knowledge(producer, labels)` | `Knowledge` with `items` and the `text` to put in the prompt |
+| `record(producer, output, *, labels, applied, subject)` | the run id a verdict cites |
+| `judge(run, verdict, reason, reason_code, edited, reviewer)` | nothing |
+| `propose(kind, content, from_run, producer, labels, new_labels, item_id, veto)` | `Candidate` with `id`, `version`, `status` and `overlaps`, the current items of the same kind one run may carry with it |
+| `approve(item_id, version, approver)` | `Approval` with `id`, `version`, `status`, `approver`, `veto`, `compaction_due` when one run would carry more than five items, and `export_error` and `folder_error` when a step after the approval failed |
+| `check_call(tool, arguments, producer)` | `Decision` with `action` of allow, block or ask, `veto` and `reason` |
+
+A tool that refuses, such as a proposal from a run nobody corrected, raises `ToolError` with the reason.
+
+## Adapters
+
+LangChain `create_agent` middleware fetches the items once per run and puts them in the system message, records the final answer and refuses a vetoed tool call:
+
+```python
+from nodloop.langchain import NodloopMiddleware
+
+mw = NodloopMiddleware(c, "support-bot", acme)
+agent = create_agent(model, tools, middleware=[mw])
+await agent.ainvoke({"messages": [...]})
+await c.judge(mw.run, "approve")
+```
+
+OpenAI Agents SDK hooks and a tool input guardrail:
+
+```python
+from nodloop.openai_agents import NodloopHooks, veto_guardrail
+
+hooks = NodloopHooks(c, "support-bot", acme)
+agent = Agent(name="support", instructions=hooks.instructions("You help with refunds"), tools=[...])
+await Runner.run(agent, "refund?", hooks=hooks)
+```
+
+Pass `veto_guardrail(c, "support-bot")` in a tool's `tool_input_guardrails`.
+
+Claude Agent SDK hooks, the same loop the Claude Code plugin runs:
+
+```python
+from nodloop.claude_agent import NodloopHooks
+
+hooks = NodloopHooks(c, "support-bot", acme)
+options = ClaudeAgentOptions(hooks=hooks.hooks())
+```
+
+Use one adapter instance per run or conversation, since it keeps the items it handed out and the id of the run it recorded.
+
+## A shared server
+
+`Client(url="https://nodloop.example/mcp", key="nl_...")` connects to `nodloop-server serve` instead of a local binary. The key decides the tenant and what the client may do, and an approval through it is recorded under the key's name.
+
+## More
+
+The [nodloop README](https://github.com/jeon-jihyeon/nodloop#readme) covers labels, vetoes, reports and the server. MIT licensed.

nodloop-0.7.0/README.md

@@ -0,0 +1,86 @@
+# nodloop for Python
+
+Record what your agent answered, take a person's verdict on it, and hand the corrections they approve to the agent's next run in the same situation. This is the Python client of [nodloop](https://github.com/jeon-jihyeon/nodloop).
+
+```
+pip install nodloop
+pip install "nodloop[langchain]"      # or openai-agents, claude-agent
+```
+
+The client starts a local `nodloop mcp` over stdio, so no server runs. It uses `NODLOOP_BIN`, then the binary the Claude Code plugin keeps under `~/.nodloop/bin`, then `nodloop` on PATH, and otherwise downloads the release of its own version from GitHub and checks it against the release checksums. It requires Python 3.10 or newer and is tested on Linux with Python 3.12.
+
+## The loop
+
+```python
+from nodloop import Client
+
+acme = {"tenant": ["acme"], "task": ["refund"]}
+
+async with Client() as c:
+    knowledge = await c.knowledge("support-bot", acme)
+    prompt = f"{system_prompt}\n\n{knowledge.text}"  # empty text when nothing is approved
+    answer = await my_agent(prompt)
+    run = await c.record("support-bot", answer, labels=acme, applied=knowledge.items)
+
+    # later, when a person reads the answer
+    await c.judge(run, "reject", reason="the refund window was missing", reason_code="scope")
+    candidate = await c.propose("judgment", "Quote the refund window before the steps", from_run=run)
+    approval = await c.approve(candidate.id, candidate.version, approver="ann")
+```
+
+From then on every `knowledge("support-bot", acme)` carries the item, and a run of another tenant never does. `judge` takes `approve`, `edit` with `edited=` holding the corrected output, `reject` with what was wrong, or `withdraw` to take back the verdict before it.
+
+| Method | Returns |
+|---|---|
+| `knowledge(producer, labels)` | `Knowledge` with `items` and the `text` to put in the prompt |
+| `record(producer, output, *, labels, applied, subject)` | the run id a verdict cites |
+| `judge(run, verdict, reason, reason_code, edited, reviewer)` | nothing |
+| `propose(kind, content, from_run, producer, labels, new_labels, item_id, veto)` | `Candidate` with `id`, `version`, `status` and `overlaps`, the current items of the same kind one run may carry with it |
+| `approve(item_id, version, approver)` | `Approval` with `id`, `version`, `status`, `approver`, `veto`, `compaction_due` when one run would carry more than five items, and `export_error` and `folder_error` when a step after the approval failed |
+| `check_call(tool, arguments, producer)` | `Decision` with `action` of allow, block or ask, `veto` and `reason` |
+
+A tool that refuses, such as a proposal from a run nobody corrected, raises `ToolError` with the reason.
+
+## Adapters
+
+LangChain `create_agent` middleware fetches the items once per run and puts them in the system message, records the final answer and refuses a vetoed tool call:
+
+```python
+from nodloop.langchain import NodloopMiddleware
+
+mw = NodloopMiddleware(c, "support-bot", acme)
+agent = create_agent(model, tools, middleware=[mw])
+await agent.ainvoke({"messages": [...]})
+await c.judge(mw.run, "approve")
+```
+
+OpenAI Agents SDK hooks and a tool input guardrail:
+
+```python
+from nodloop.openai_agents import NodloopHooks, veto_guardrail
+
+hooks = NodloopHooks(c, "support-bot", acme)
+agent = Agent(name="support", instructions=hooks.instructions("You help with refunds"), tools=[...])
+await Runner.run(agent, "refund?", hooks=hooks)
+```
+
+Pass `veto_guardrail(c, "support-bot")` in a tool's `tool_input_guardrails`.
+
+Claude Agent SDK hooks, the same loop the Claude Code plugin runs:
+
+```python
+from nodloop.claude_agent import NodloopHooks
+
+hooks = NodloopHooks(c, "support-bot", acme)
+options = ClaudeAgentOptions(hooks=hooks.hooks())
+```
+
+Use one adapter instance per run or conversation, since it keeps the items it handed out and the id of the run it recorded.
+
+## A shared server
+
+`Client(url="https://nodloop.example/mcp", key="nl_...")` connects to `nodloop-server serve` instead of a local binary. The key decides the tenant and what the client may do, and an approval through it is recorded under the key's name.
+
+## More
+
+The [nodloop README](https://github.com/jeon-jihyeon/nodloop#readme) covers labels, vetoes, reports and the server. MIT licensed.

{nodloop-0.6.6 → nodloop-0.7.0}/pyproject.toml

@@ -1,11 +1,17 @@
 [project]
 name = "nodloop"
-version = "0.6.6"
+version = "0.7.0"
 description = "Record AI runs and the verdicts people give on them, and hand the knowledge they approve to the next run in the same place"
+readme = "README.md"
 license = "MIT"
+keywords = ["ai", "agents", "feedback", "human-in-the-loop", "langchain", "mcp", "memory"]
 requires-python = ">=3.10"
 dependencies = ["mcp>=2.0"]
 
+[project.urls]
+Homepage = "https://github.com/jeon-jihyeon/nodloop"
+Repository = "https://github.com/jeon-jihyeon/nodloop"
+
 [project.optional-dependencies]
 langchain = ["langchain>=1.0"]
 openai-agents = ["openai-agents>=0.3.3"]

nodloop-0.7.0/src/nodloop/__init__.py

@@ -0,0 +1,5 @@
+"""Record AI runs and the verdicts people give on them, and hand the knowledge they approve to the next run in the same place"""
+
+from .client import Approval, Candidate, Client, Decision, Item, Knowledge, ToolError
+
+__all__ = ["Approval", "Candidate", "Client", "Decision", "Item", "Knowledge", "ToolError"]

{nodloop-0.6.6 → nodloop-0.7.0}/src/nodloop/claude_agent.py

@@ -49,7 +49,7 @@ class NodloopHooks:
         # A turn without one records nothing
         answer = input_data.get("last_assistant_message") or ""
         if answer.strip():
-            self.run = await self.client.record(self.producer, answer, self.labels, self.applied)
+            self.run = await self.client.record(self.producer, answer, labels=self.labels, applied=self.applied)
         return {}
 
     async def pre_tool_use(self, input_data: dict[str, Any], tool_use_id: str | None, context: Any) -> dict[str, Any]:

{nodloop-0.6.6 → nodloop-0.7.0}/src/nodloop/client.py

@@ -14,10 +14,10 @@ from mcp.client.streamable_http import create_mcp_http_client, streamable_http_c
 
 from . import binary
 
-__all__ = ["Client", "Decision", "Item", "Knowledge", "ToolError"]
+__all__ = ["Approval", "Candidate", "Client", "Decision", "Item", "Knowledge", "ToolError"]
 
 # The binary release the client fetches when no nodloop is installed
-VERSION = "0.6.6"
+VERSION = "0.7.0"
 
 
 class ToolError(RuntimeError):
@@ -52,6 +52,36 @@ class Decision:
         return self.action == "allow"
 
 
+@dataclass(frozen=True)
+class Candidate:
+    """A proposed knowledge version that waits for a person to approve it"""
+
+    id: str
+    version: int
+    status: str
+    # The current items of the same kind that one run may carry with the candidate, each as the ledger records it
+    overlaps: list[dict[str, Any]] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class Approval:
+    """An approved knowledge version"""
+
+    id: str
+    version: int
+    status: str
+    # The approver the records keep, which a server sets to the key's name
+    approver: str
+    # Whether the approved version carries a veto the guard now applies
+    veto: bool = False
+    # Whether one run would carry more than five items so a compaction is due
+    compaction_due: bool = False
+    # Why approved.md or the veto file could not be written, while the approval itself stands
+    export_error: str = ""
+    # Why the items one run carries with it could not be read, while the approval itself stands
+    folder_error: str = ""
+
+
 @dataclass(frozen=True)
 class Knowledge:
     """The approved items a run receives and the text that carries them into its prompt"""
@@ -66,7 +96,7 @@ class Client:
 
     1. by default it starts `nodloop mcp` over stdio, so nothing runs as a server
     2. record_dir names the records and else NODLOOP_RECORD_DIR, config.json or ~/.nodloop/records decide as in the CLI
-    3. url and key connect to `nodloop server serve` instead, where the key decides the tenant and the role
+    3. url and key connect to `nodloop-server serve` instead, where the key decides the tenant and the role
     4. use it as an async context manager so the process or the connection ends with the block
     """
 
@@ -136,6 +166,7 @@ class Client:
         self,
         producer: str,
         output: Any,
+        *,
         labels: dict[str, list[str]] | None = None,
         applied: list[Item] | None = None,
         subject: str = "",
@@ -176,7 +207,7 @@ class Client:
         new_labels: bool = False,
         item_id: str = "",
         veto: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
+    ) -> Candidate:
         """Proposes a candidate a person approves later, from a corrected run or for a producer and labels
 
         veto names a tool call the judgment forbids as tool, when and example, as the MCP tool propose takes it
@@ -191,11 +222,22 @@ class Client:
             args["labels"] = labels
         if new_labels:
             args["new_labels"] = True
-        return await self.call("propose", args)
+        answer = await self.call("propose", args)
+        return Candidate(answer["id"], answer["version"], answer["status"], answer.get("overlaps") or [])
 
-    async def approve(self, item_id: str, version: int, approver: str) -> dict[str, Any]:
+    async def approve(self, item_id: str, version: int, approver: str) -> Approval:
         """Approves a candidate on behalf of the named person"""
-        return await self.call("approve", {"id": item_id, "version": version, "approver": approver})
+        answer = await self.call("approve", {"id": item_id, "version": version, "approver": approver})
+        return Approval(
+            answer["id"],
+            answer["version"],
+            answer["status"],
+            answer["approver"],
+            veto=bool(answer.get("veto")),
+            compaction_due=bool((answer.get("folder") or {}).get("compaction_due")),
+            export_error=answer.get("export_error", ""),
+            folder_error=answer.get("folder_error", ""),
+        )
 
     async def check_call(self, tool: str, arguments: dict[str, Any], producer: str = "") -> Decision:
         """Whether a veto approved for the producer blocks or asks about a tool call before the agent runs it

{nodloop-0.6.6 → nodloop-0.7.0}/src/nodloop/langchain.py

@@ -1,6 +1,6 @@
 """LangChain agents middleware for nodloop
 
-1. every model call gets the approved items of the place in its system message
+1. every model call of a run gets the approved items of the place in its system message, fetched once per run
 2. the final answer of the agent is recorded as a run naming the items it got
 3. every tool call is checked against the approved vetoes and a blocked one answers the model with the reason
 """
@@ -13,7 +13,7 @@ from typing import Any
 from langchain.agents.middleware import AgentMiddleware
 from langchain_core.messages import AIMessage, SystemMessage, ToolMessage
 
-from .client import Client, Item
+from .client import Client, Item, Knowledge
 
 Labels = dict[str, list[str]]
 
@@ -30,6 +30,8 @@ class NodloopMiddleware(AgentMiddleware):
         self.producer = producer
         self.labels = labels or {}
         self.applied: list[Item] = []
+        # The items of the current run, fetched on its first model call and dropped once the run is recorded
+        self._knowledge: Knowledge | None = None
         # The run the final answer was recorded as so a verdict can cite it
         self.run: str = ""
 
@@ -37,18 +39,19 @@ class NodloopMiddleware(AgentMiddleware):
         return self.labels(state) if callable(self.labels) else self.labels
 
     async def awrap_model_call(self, request: Any, handler: Callable[[Any], Any]) -> Any:
-        knowledge = await self.client.knowledge(self.producer, self._labels(request.state))
-        self.applied = knowledge.items
-        if not knowledge.text:
+        if self._knowledge is None:
+            self._knowledge = await self.client.knowledge(self.producer, self._labels(request.state))
+            self.applied = self._knowledge.items
+        text = self._knowledge.text
+        if not text:
             return await handler(request)
-        base = request.system_message.content if request.system_message else ""
-        system = SystemMessage(content=f"{base}\n\n{knowledge.text}" if base else knowledge.text)
-        return await handler(request.override(system_message=system))
+        return await handler(request.override(system_message=_with_text(request.system_message, text)))
 
     async def aafter_agent(self, state: Any, runtime: Any) -> None:
         answers = [m for m in state["messages"] if isinstance(m, AIMessage)]
         if answers:
-            self.run = await self.client.record(self.producer, answers[-1].text, self._labels(state), self.applied)
+            self.run = await self.client.record(self.producer, answers[-1].text, labels=self._labels(state), applied=self.applied)
+        self._knowledge = None
 
     async def awrap_tool_call(self, request: Any, handler: Callable[[Any], Any]) -> Any:
         call = request.tool_call
@@ -60,3 +63,16 @@ class NodloopMiddleware(AgentMiddleware):
             tool_call_id=call["id"],
             status="error",
         )
+
+
+def _with_text(system: SystemMessage | None, text: str) -> SystemMessage:
+    """The system message with the text after its content, keeping content blocks as they are
+
+    The text of blocks joins them as they are, so the new text leads with the blank line
+    """
+    if system is None:
+        return SystemMessage(content=text)
+    after = f"\n\n{text}" if system.text else text
+    if isinstance(system.content, str):
+        return system.model_copy(update={"content": system.content + after})
+    return system.model_copy(update={"content": [*system.content, {"type": "text", "text": after}]})

{nodloop-0.6.6 → nodloop-0.7.0}/src/nodloop/openai_agents.py

@@ -44,7 +44,7 @@ class NodloopHooks(RunHooks):
 
     async def on_agent_end(self, context: Any, agent: Any, output: Any) -> None:
         text = output if isinstance(output, str) else json.dumps(output, default=str)
-        self.run = await self.client.record(self.producer, text, self.labels, self.applied)
+        self.run = await self.client.record(self.producer, text, labels=self.labels, applied=self.applied)
 
 
 def veto_guardrail(client: Client, producer: str = "") -> Any:

{nodloop-0.6.6 → nodloop-0.7.0}/tests/conftest.py

@@ -17,6 +17,14 @@ def binary(tmp_path_factory: pytest.TempPathFactory) -> str:
     return str(out)
 
 
+@pytest.fixture(scope="session")
+def server_binary(tmp_path_factory: pytest.TempPathFactory) -> str:
+    """The nodloop-server of this checkout built once for the session"""
+    out = tmp_path_factory.mktemp("bin") / "nodloop-server"
+    subprocess.run(["go", "build", "-o", str(out), "./cmd/nodloop-server"], cwd=ROOT / "server", check=True)
+    return str(out)
+
+
 @pytest.fixture(autouse=True)
 def home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
     """A home of the test so an approval never writes a veto file under the real one"""
@@ -32,15 +40,15 @@ def records(tmp_path: Path) -> str:
 
 
 @pytest.fixture
-def server(binary: str, tmp_path: Path):
+def server(server_binary: str, tmp_path: Path):
     """A nodloop server on a free port with an approver key of tenant acme, yielding its url and key"""
     env = dict(os.environ)
-    add = [binary, "server", "key", "add", "ann", "--tenant", "acme", "--role", "approver"]
+    add = [server_binary, "key", "add", "ann", "--tenant", "acme", "--role", "approver"]
     key = subprocess.run(add, env=env, check=True, capture_output=True, text=True).stdout.strip()
     with socket.socket() as s:
         s.bind(("127.0.0.1", 0))
         port = s.getsockname()[1]
-    serve = [binary, "server", "serve", "--addr", f"127.0.0.1:{port}", "--record-dir", str(tmp_path / "records")]
+    serve = [server_binary, "serve", "--addr", f"127.0.0.1:{port}", "--record-dir", str(tmp_path / "records")]
     proc = subprocess.Popen(serve, env=env, stderr=subprocess.DEVNULL)
     for _ in range(100):
         try:

{nodloop-0.6.6 → nodloop-0.7.0}/tests/test_adapters.py

@@ -17,11 +17,11 @@ NO_RM = {"tool": "Bash", "when": [{"field": "commands", "match": "(?m)^rm "}], "
 
 async def seed(c: Client) -> None:
     """An approved item for acme and an approved veto on rm"""
-    run = await c.record("bot", "answer", ACME)
+    run = await c.record("bot", "answer", labels=ACME)
     await c.judge(run, "reject", reason="missing the window")
     for item_id, content, veto in (("window", "Quote the refund window", None), ("no-rm", "Never run rm", NO_RM)):
         p = await c.propose("judgment", content, from_run=run, item_id=item_id, veto=veto)
-        await c.approve(p["id"], p["version"], "ann")
+        await c.approve(p.id, p.version, "ann")
 
 
 async def runs(c: Client) -> list[str]:
@@ -54,6 +54,10 @@ async def test_langchain_middleware(binary: str, records: str) -> None:
             return ToolMessage("ran", tool_call_id=request.tool_call["id"])
 
         await mw.awrap_model_call(ModelRequest(system_message=SystemMessage("You help with refunds")), model)
+        first = mw.applied
+        blocks = [{"type": "text", "text": "You help"}, {"type": "text", "text": "with refunds"}]
+        await mw.awrap_model_call(ModelRequest(system_message=SystemMessage(content=blocks)), model)
+        fetched_once = mw.applied is first
         blocked = await mw.awrap_tool_call(SimpleNamespace(tool_call={"id": "t1", "name": "Bash", "args": {"command": "rm -rf /x"}}), tool)
         allowed = await mw.awrap_tool_call(SimpleNamespace(tool_call={"id": "t2", "name": "Bash", "args": {"command": "ls"}}), tool)
         await mw.aafter_agent({"messages": [HumanMessage("refund?"), AIMessage("The window is 30 days")]}, None)
@@ -61,6 +65,9 @@ async def test_langchain_middleware(binary: str, records: str) -> None:
 
     assert seen[0].system_message.content.startswith("You help with refunds\n\nnodloop: corrections")
     assert "[window v1 judgment] Quote the refund window" in seen[0].system_message.content
+    assert fetched_once and [i.id for i in first] == ["window"]
+    assert seen[1].system_message.content[:2] == blocks
+    assert seen[1].system_message.content[2]["text"].startswith("\n\nnodloop: corrections")
     assert blocked.status == "error" and "no-rm" in blocked.content
     assert allowed.content == "ran"
     assert mw.run in recorded
@@ -111,10 +118,16 @@ async def test_langchain_create_agent(binary: str, records: str) -> None:
     from langchain_core.language_models.fake_chat_models import GenericFakeChatModel
     from langchain_core.tools import tool
 
+    prompts: list[str] = []
+
     class Scripted(GenericFakeChatModel):
         def bind_tools(self, tools: Any, **kwargs: Any) -> "Scripted":
             return self
 
+        async def _agenerate(self, messages: Any, *args: Any, **kwargs: Any) -> Any:
+            prompts.append(messages[0].text)
+            return await super()._agenerate(messages, *args, **kwargs)
+
     ran: list[str] = []
 
     @tool
@@ -129,11 +142,11 @@ async def test_langchain_create_agent(binary: str, records: str) -> None:
     async with Client(records, binary) as c:
         await seed(c)
         # A veto names the tool as this agent calls it
-        run = await c.record("bot", "ran rm", ACME)
+        run = await c.record("bot", "ran rm", labels=ACME)
         await c.judge(run, "reject", reason="never rm")
         veto = {"tool": "bash", "when": [{"field": "commands", "match": "(?m)^rm "}], "example": {"command": "rm -rf /data"}}
         p = await c.propose("judgment", "Never run rm through bash", from_run=run, item_id="no-rm-bash", veto=veto)
-        await c.approve(p["id"], p["version"], "ann")
+        await c.approve(p.id, p.version, "ann")
         mw = NodloopMiddleware(c, "bot", ACME)
         agent = create_agent(Scripted(messages=script), tools=[bash], system_prompt="You help", middleware=[mw])
 
@@ -144,3 +157,5 @@ async def test_langchain_create_agent(binary: str, records: str) -> None:
     assert ran == []
     assert tool_messages and "nodloop veto" in tool_messages[0].content
     assert mw.run in recorded
+    assert len(prompts) == 2 and all(p.startswith("You help\n\nnodloop: corrections") for p in prompts)
+    assert [i.id for i in mw.applied] == ["window"]

{nodloop-0.6.6 → nodloop-0.7.0}/tests/test_client.py

@@ -13,15 +13,16 @@ NO_RM = {
 
 async def test_loop(binary: str, records: str) -> None:
     async with Client(records, binary) as c:
-        run = await c.record("support-bot", "Here are the refund steps", ACME)
+        run = await c.record("support-bot", "Here are the refund steps", labels=ACME)
         await c.judge(run, "reject", reason="the refund window was missing", reason_code="scope")
         proposed = await c.propose("judgment", "Quote the refund window before the steps", from_run=run, item_id="refund-window")
-        await c.approve(proposed["id"], proposed["version"], "ann")
+        approved = await c.approve(proposed.id, proposed.version, "ann")
 
         acme = await c.knowledge("support-bot", ACME)
         globex = await c.knowledge("support-bot", {"tenant": ["globex"], "task": ["refund"]})
-        nxt = await c.record("support-bot", "The window is 30 days. Steps follow", ACME, acme.items)
+        nxt = await c.record("support-bot", "The window is 30 days. Steps follow", labels=ACME, applied=acme.items)
 
+    assert (approved.veto, approved.compaction_due, approved.export_error, approved.folder_error) == (False, False, "", "")
     assert [i.id for i in acme.items] == ["refund-window"]
     assert acme.text.startswith("nodloop: corrections a person approved")
     assert "- [refund-window v1 judgment] Quote the refund window before the steps" in acme.text
@@ -31,7 +32,7 @@ async def test_loop(binary: str, records: str) -> None:
 
 async def test_refusal_is_a_tool_error(binary: str, records: str) -> None:
     async with Client(records, binary) as c:
-        run = await c.record("support-bot", "answer", ACME)
+        run = await c.record("support-bot", "answer", labels=ACME)
         with pytest.raises(ToolError, match="needs an edit or a reject"):
             await c.propose("judgment", "x", from_run=run)
 
@@ -46,13 +47,14 @@ async def test_refusal_is_a_tool_error(binary: str, records: str) -> None:
 )
 async def test_check_call(binary: str, records: str, tool: str, arguments: dict, action: str) -> None:
     async with Client(records, binary) as c:
-        run = await c.record("ops-bot", "ran rm -rf /data", {"env": ["prod"]})
+        run = await c.record("ops-bot", "ran rm -rf /data", labels={"env": ["prod"]})
         await c.judge(run, "reject", reason="never delete data")
         proposed = await c.propose("judgment", "Never delete under /data", from_run=run, item_id="no-rm-data", veto=NO_RM)
-        await c.approve(proposed["id"], proposed["version"], "ann")
+        approved = await c.approve(proposed.id, proposed.version, "ann")
 
         decision = await c.check_call(tool, arguments)
 
+    assert approved.veto
     assert decision.action == action
     assert decision.allowed == (action == "allow")
 
@@ -60,13 +62,14 @@ async def test_check_call(binary: str, records: str, tool: str, arguments: dict,
 async def test_server(server: tuple[str, str]) -> None:
     url, key = server
     async with Client(url=url, key=key) as c:
-        run = await c.record("support-bot", "Here are the refund steps", ACME)
+        run = await c.record("support-bot", "Here are the refund steps", labels=ACME)
         await c.judge(run, "reject", reason="the refund window was missing")
         proposed = await c.propose("judgment", "Quote the refund window", from_run=run, item_id="refund-window")
-        approved = await c.approve(proposed["id"], proposed["version"], "mallory")
+        approved = await c.approve(proposed.id, proposed.version, "mallory")
         acme = await c.knowledge("support-bot", ACME)
 
-    assert approved["approver"] == "ann"
+    assert (approved.id, approved.version, approved.status, approved.approver) == ("refund-window", 1, "approved", "ann")
+    assert (proposed.id, proposed.status) == ("refund-window", "candidate")
     assert [i.id for i in acme.items] == ["refund-window"]
 
 
@@ -75,3 +78,21 @@ async def test_server_refuses_a_wrong_key(server: tuple[str, str]) -> None:
     with pytest.raises(MCPError):
         async with Client(url=url, key="nl_wrong") as c:
             await c.knowledge("support-bot", ACME)
+
+
+async def test_record_takes_keywords_after_output() -> None:
+    with pytest.raises(TypeError):
+        await Client().record("support-bot", "answer", ACME)  # type: ignore[misc]
+
+
+async def test_approval_says_a_compaction_is_due(binary: str, records: str) -> None:
+    async with Client(records, binary) as c:
+        run = await c.record("support-bot", "Here are the refund steps", labels=ACME)
+        await c.judge(run, "reject", reason="the refund window was missing")
+        approvals = []
+        for n in range(6):
+            proposed = await c.propose("judgment", f"Refund rule number {n}", from_run=run, item_id=f"rule-{n}")
+            approvals.append(await c.approve(proposed.id, proposed.version, "ann"))
+
+    assert [a.compaction_due for a in approvals] == [False] * 5 + [True]
+    assert all(a.folder_error == "" for a in approvals)

{nodloop-0.6.6 → nodloop-0.7.0}/uv.lock

@@ -899,7 +899,7 @@ wheels = [
 
 [[package]]
 name = "nodloop"
-version = "0.6.6"
+version = "0.7.0"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

nodloop-0.6.6/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.5
-Name: nodloop
-Version: 0.6.6
-Summary: Record AI runs and the verdicts people give on them, and hand the knowledge they approve to the next run in the same place
-License-Expression: MIT
-Requires-Python: >=3.10
-Requires-Dist: mcp>=2.0
-Provides-Extra: claude-agent
-Requires-Dist: claude-agent-sdk>=0.1; extra == 'claude-agent'
-Provides-Extra: langchain
-Requires-Dist: langchain>=1.0; extra == 'langchain'
-Provides-Extra: openai-agents
-Requires-Dist: openai-agents>=0.3.3; extra == 'openai-agents'

nodloop-0.6.6/src/nodloop/__init__.py

@@ -1,5 +0,0 @@
-"""Record AI runs and the verdicts people give on them, and hand the knowledge they approve to the next run in the same place"""
-
-from .client import Client, Decision, Item, Knowledge, ToolError
-
-__all__ = ["Client", "Decision", "Item", "Knowledge", "ToolError"]