backloop-sdk 0.2.0__tar.gz → 0.2.1__tar.gz

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/.gitignore

@@ -1,8 +1,13 @@
 node_modules/
 dist/
-data/
+.backloop/
+*.db
+*.db-*
 __pycache__/
 *.egg-info/
 .venv/
 .env
+.env.*
+!.env.example
 .DS_Store
+dist-website/

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: backloop-sdk
-Version: 0.2.0
+Version: 0.2.1
 Summary: Python SDK for the Agent Feedback Protocol: validate, send and receive structured feedback from AI agents.
 Project-URL: Homepage, https://trybackloop.com
 Project-URL: Specification, https://trybackloop.com/spec/

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "backloop-sdk"
-version = "0.2.0"
+version = "0.2.1"
 description = "Python SDK for the Agent Feedback Protocol: validate, send and receive structured feedback from AI agents."
 readme = "README.md"
 license = "Apache-2.0"

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/src/backloop/__init__.py

@@ -47,7 +47,7 @@ from .validate import (
     validate_submission,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "ACK_SCHEMA",

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/src/backloop/requests_recorder.py

@@ -118,6 +118,63 @@ def detect_agent(headers: Optional[HeadersLike]) -> Optional[str]:
     return client["name"] if client else None
 
 
+def json_rpc_call(body: Optional[str]) -> Optional[Tuple[str, Any]]:
+    """Like ``jsonRpcCall`` in ``requests.ts``: (``"tools/call search"``, arguments), or None when it isn't JSON-RPC."""
+    if not body:
+        return None
+    try:
+        msg = json.loads(body)
+    except ValueError:
+        return None
+    if isinstance(msg, list):
+        return ("batch", None) if any(isinstance(m, dict) and m.get("jsonrpc") == "2.0" for m in msg) else None
+    if not isinstance(msg, dict) or msg.get("jsonrpc") != "2.0" or not isinstance(msg.get("method"), str):
+        return None
+    method = clip(msg["method"], 64)
+    params = msg.get("params") if isinstance(msg.get("params"), dict) else {}
+    name = params.get("name")
+    if method in ("tools/call", "prompts/get") and isinstance(name, str) and name:
+        return f"{method} {clip(name, 128)}", params.get("arguments")
+    return method, ({"uri": params["uri"]} if "uri" in params else None)
+
+
+def json_rpc_error(body: Optional[str]) -> Optional[str]:
+    """Like ``jsonRpcError`` in ``requests.ts``: a JSON-RPC error, or an MCP tool result's ``isError`` text."""
+    if not body:
+        return None
+    text = body.strip()
+    if text[:1] not in ("[", "{"):
+        data = [line[5:].strip() for line in text.splitlines() if line.startswith("data:")]
+        text = data[-1] if data else ""
+    try:
+        msg = json.loads(text)
+    except ValueError:
+        return None
+    for m in msg if isinstance(msg, list) else [msg]:
+        if not isinstance(m, dict):
+            continue
+        err = m.get("error")
+        if isinstance(err, dict):
+            return err["message"] if isinstance(err.get("message"), str) else f"JSON-RPC error {err.get('code', '')}".strip()
+        result = m.get("result")
+        if isinstance(result, dict) and result.get("isError") is True:
+            for c in result.get("content") or []:
+                if isinstance(c, dict) and isinstance(c.get("text"), str):
+                    return c["text"]
+            return "The tool returned isError"
+    return None
+
+
+def _is_transport_probe(method: str, path: str, status: int, headers: Mapping[str, str]) -> bool:
+    """An answer the MCP spec asks for: 405 to a GET/DELETE the server doesn't offer, 401 to a request without a credential."""
+    mcp = bool(re.search(r"/mcp/?$", path)) or "mcp-session-id" in headers
+    if status == 401:
+        return mcp
+    if status != 405 or method.upper() not in ("GET", "DELETE"):
+        return False
+    return mcp or "text/event-stream" in headers.get("accept", "")
+
+
 def collapse_path(path: str) -> str:
     """``/companies/cmp_001/jobs`` -> ``/companies/:id/jobs``: the route when the framework names none."""
     return "/".join(":id" if seg and _ID_SEGMENT.match(seg) else seg for seg in path.split("/")) or "/"
@@ -208,6 +265,9 @@ class _Recorder:
         error: Optional[BaseException] = None,
     ) -> None:
         try:
+            if _is_transport_probe(method, path, status, headers):
+                return
+            rpc = json_rpc_call(body.decode("utf-8", "replace") if body and method.upper() == "POST" else None)
             event: Dict[str, Any] = {"id": new_id("ev"), "kind": "http_request"}
             session_id = headers.get("x-agent-session") or headers.get("mcp-session-id")
             if session_id:
@@ -220,18 +280,24 @@ class _Recorder:
                 event["client"] = client
             event.update(
                 method=method.upper(),
-                route=clip(self.route_for(request, framework_route, path), 512),
+                route=clip(self.route_for(request, framework_route, path) + (" " + rpc[0] if rpc else ""), 512),
                 status=int(status),
                 started_at=iso_now(started),
                 duration_ms=max(0, round(time.time() * 1000 - started)),
             )
             text = response.decode("utf-8", "replace") if response else None
+            rpc_error = json_rpc_error(text) if rpc and error is None and status < 400 else None
             if error is not None:
                 event["error"] = self.scrub.error(str(error) or type(error).__name__)
+            elif rpc_error is not None:
+                event["ok"] = False
+                event["error"] = self.scrub.error(rpc_error)
             elif status >= 400 and text:
                 event["error"] = self.scrub.error(text)
-            # The query, as requests.ts sends it ("a=1 b=2"); without one, the request body.
-            if query:
+            # A JSON-RPC call's arguments; else the query, as requests.ts sends it ("a=1 b=2"); without one, the request body.
+            if rpc and rpc[1] is not None:
+                preview = self.preview(json.dumps(rpc[1], ensure_ascii=False, separators=(",", ":")))
+            elif query:
                 preview = self.preview(urllib.parse.unquote(query).replace("&", " "))
             else:
                 preview = self.preview(body.decode("utf-8", "replace")) if body else None

{backloop_sdk-0.2.0 → backloop_sdk-0.2.1}/tests/test_requests.py

@@ -141,6 +141,33 @@ class ASGITest(unittest.TestCase):
             },
         )
 
+    def test_mcp_calls_are_named_by_tool_and_spec_answers_are_skipped(self):
+        def mcp(body):
+            return asgi_app(body=body)
+
+        headers = {"User-Agent": "Codex/0.50", "Content-Type": "application/json"}
+        app, events = recorder(asgi_app(status=405, body=b"Method not allowed.", content_type=b"text/plain"))
+        call_asgi(app, path="/mcp", headers={"User-Agent": "Codex/0.50", "Accept": "text/event-stream"})
+        app, challenged = recorder(asgi_app(status=401, body=b'{"error":"invalid_token"}'))
+        call_asgi(app, path="/mcp", method="POST", headers={"User-Agent": "claude-code/2.1.0", "Content-Type": "application/json"}, body=b'{"jsonrpc":"2.0","id":0,"method":"initialize"}')
+        app.flush()
+        self.assertEqual(events + challenged, [])
+
+        app, events = recorder(mcp(b'{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"ok"}]}}'))
+        req = b'{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"search","arguments":{"q":"fintech"}}}'
+        call_asgi(app, path="/mcp", method="POST", headers=headers, body=req)
+        app.flush()
+        [event] = events
+        self.assertEqual(event["route"], "/mcp tools/call search")
+        self.assertEqual(event["input"], '{"q":"fintech"}')
+        self.assertNotIn("ok", event)
+
+        app, events = recorder(mcp(b'{"jsonrpc":"2.0","id":1,"result":{"isError":true,"content":[{"type":"text","text":"upstream timed out"}]}}'))
+        call_asgi(app, path="/mcp", method="POST", headers=headers, body=req)
+        app.flush()
+        [event] = events
+        self.assertEqual((event["ok"], event["error"]), (False, "upstream timed out"))
+
     def test_humans_are_not_recorded_unless_asked(self):
         app, events = recorder(asgi_app())
         call_asgi(app, headers={"User-Agent": BROWSER})