agent-status-sdk 2.4.2__tar.gz → 2.4.3__tar.gz

{agent_status_sdk-2.4.2 → agent_status_sdk-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-status-sdk
-Version: 2.4.2
+Version: 2.4.3
 Summary: Fail-open wrap for live MCP and personal-agent traffic on AgentStatus.
 Project-URL: Homepage, https://agentstatus.dev
 Project-URL: Dashboard, https://agentstatus.dev

{agent_status_sdk-2.4.2 → agent_status_sdk-2.4.3}/agent_status/__init__.py

@@ -2,7 +2,7 @@
 
 from agent_status.observe import Agent, job_name, observe, observe_url, report_job, report_tool_call, track
 
-__version__ = "2.4.2"
+__version__ = "2.4.3"
 
 __all__ = [
     "Agent",

{agent_status_sdk-2.4.2 → agent_status_sdk-2.4.3}/agent_status/observe.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import hashlib
 import inspect
 import json
 import logging
@@ -62,6 +63,8 @@ def report_tool_call(
     token_out: Optional[int] = None,
     landed: Optional[bool] = None,
     proof: Optional[Dict[str, Any]] = None,
+    intent: str = "",
+    user_name: str = "",
 ) -> None:
     """POST one tools/call. Never raises."""
     aid = (agent_id or os.environ.get("AGENTSTATUS_AGENT_ID") or "").strip()
@@ -82,8 +85,14 @@ def report_tool_call(
         "source": "sdk",
         "kind": kind,
     }
-    if user:
-        payload["user"] = str(user)[:120]
+    if intent:
+        payload["intent"] = str(intent)[:400]
+    who = _stable_actor(user)
+    if who:
+        payload["user"] = who
+    named = _actor_name(user_name)
+    if named:
+        payload["user_name"] = named
     if job:
         payload["job"] = str(job)[:80]
     if status:
@@ -128,6 +137,197 @@ def job_name(name: str) -> str:
     return label.replace("get_", "").replace("book_", "").replace("check_", "")[:40]
 
 
+def _output_schemas(server: Any) -> Dict[str, Dict[str, Any]]:
+    """Advertised output schemas keyed by tool name. Empty when the server has none."""
+    found: Dict[str, Dict[str, Any]] = {}
+    seen = []
+    for candidate in (
+        server,
+        getattr(server, "_mcp_server", None),
+        getattr(server, "server", None),
+    ):
+        manager = getattr(candidate, "_tool_manager", None) if candidate is not None else None
+        if manager is not None and manager not in seen:
+            seen.append(manager)
+    for manager in seen:
+        tools = getattr(manager, "_tools", None)
+        if not isinstance(tools, dict):
+            continue
+        for key, tool in tools.items():
+            schema = getattr(tool, "output_schema", None) or getattr(tool, "outputSchema", None)
+            if not isinstance(schema, dict) or not schema:
+                continue
+            name = str(getattr(tool, "name", None) or key or "").strip()
+            if name:
+                found[name] = schema
+    return found
+
+
+def _already_tool_error(result: Any) -> bool:
+    if isinstance(result, dict) and result.get("isError") is True:
+        return True
+    if getattr(result, "isError", False) is True:
+        return True
+    root = getattr(result, "root", None)
+    return bool(root is not None and getattr(root, "isError", False) is True)
+
+
+def _json_object(text: str) -> Optional[Dict[str, Any]]:
+    raw = str(text or "").strip()
+    if not raw.startswith("{"):
+        return None
+    try:
+        parsed = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def _schema_payload(result: Any) -> Optional[Dict[str, Any]]:
+    """Object body to check. None when the call is already an error or has no object."""
+    if result is None or _already_tool_error(result):
+        return None
+    if isinstance(result, dict):
+        structured = result.get("structuredContent")
+        if isinstance(structured, dict):
+            return structured
+        if "content" in result or "isError" in result:
+            return _json_object(_excerpt(result))
+        return result
+    structured = getattr(result, "structuredContent", None)
+    if isinstance(structured, dict):
+        return structured
+    root = getattr(result, "root", None)
+    if root is not None and root is not result:
+        return _schema_payload(root)
+    return None
+
+
+def _schema_break(schema: Dict[str, Any], payload: Dict[str, Any]) -> str:
+    """Field-level break against an advertised object schema. Empty when it matches."""
+    if schema.get("type") not in (None, "object"):
+        return ""
+    required = schema.get("required") if isinstance(schema.get("required"), list) else []
+    props = schema.get("properties") if isinstance(schema.get("properties"), dict) else {}
+    for field in required:
+        name = str(field or "").strip()
+        if not name:
+            continue
+        if name not in payload or payload.get(name) is None:
+            return f"missing {name}"
+    types = {
+        "string": str,
+        "boolean": bool,
+        "array": list,
+        "object": dict,
+    }
+    for field, spec in props.items():
+        if field not in payload or not isinstance(spec, dict):
+            continue
+        expected = spec.get("type")
+        value = payload[field]
+        if expected in ("number", "integer"):
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                return f"wrong type {field}"
+            if expected == "integer" and isinstance(value, float) and not value.is_integer():
+                return f"wrong type {field}"
+            continue
+        want = types.get(str(expected or ""))
+        if want is not None and not isinstance(value, want):
+            return f"wrong type {field}"
+    if schema.get("additionalProperties") is False:
+        extra = [str(key) for key in payload if key not in props]
+        if extra:
+            return f"extra {extra[0]}"
+    return ""
+
+
+def _as_tool_error(result: Any, message: str) -> Any:
+    """Replace a lying success with a tool error. None when the result type cannot be closed."""
+    block = {"type": "text", "text": message}
+    if isinstance(result, dict):
+        return {"isError": True, "content": [block]}
+    target = getattr(result, "root", None)
+    holder = result if target is not None else None
+    model = target if target is not None else result
+    if hasattr(model, "model_copy"):
+        try:
+            updated = model.model_copy(update={"isError": True, "structuredContent": None, "content": [block]})
+        except Exception:
+            return None
+        if holder is not None and hasattr(holder, "model_copy"):
+            try:
+                return holder.model_copy(update={"root": updated})
+            except Exception:
+                return None
+        return updated
+    return None
+
+
+def _schema_close(schemas: Dict[str, Dict[str, Any]], name: str, result: Any) -> Optional[tuple]:
+    schema = schemas.get(str(name or "").strip())
+    if not isinstance(schema, dict) or not schema:
+        return None
+    payload = _schema_payload(result)
+    if payload is None:
+        return None
+    detail = _schema_break(schema, payload)
+    if not detail:
+        return None
+    message = f"{name} came back success and was {detail}."
+    return message, _as_tool_error(result, message), {"status": "broke", "shape": "schema", "detail": detail}
+
+
+class _BodyError(Exception):
+    """Recorded from a result body. Not raised to the host."""
+
+    def __init__(self, message: str) -> None:
+        self.message = message
+
+
+def _content_text(content: Any) -> str:
+    if not isinstance(content, (list, tuple)):
+        return ""
+    parts = []
+    for item in content:
+        text = ""
+        if isinstance(item, dict):
+            text = str(item.get("text") or "").strip()
+        else:
+            text = str(getattr(item, "text", "") or "").strip()
+        if text:
+            parts.append(text)
+    return "\n".join(parts).strip()
+
+
+def _body_error(result: Any) -> str:
+    """A completed call whose body is still an error. Empty when the call succeeded."""
+    if result is None or isinstance(result, (str, bytes, int, float, bool)):
+        return ""
+    is_error = getattr(result, "isError", None)
+    content = getattr(result, "content", None)
+    err = getattr(result, "error", None)
+    if isinstance(result, dict):
+        if is_error is None:
+            is_error = result.get("isError")
+        if content is None:
+            content = result.get("content")
+        if "error" in result:
+            err = result.get("error")
+    if is_error is True:
+        return (_content_text(content) or "The tool returned an error.")[:800]
+    if isinstance(err, str) and err.strip():
+        return err.strip()[:800]
+    if isinstance(err, dict):
+        message = str(err.get("message") or err.get("error") or "").strip()
+        if message:
+            return message[:800]
+        code = err.get("code")
+        if isinstance(code, int) and code != 0:
+            return f"The tool returned error {code}."[:800]
+    return ""
+
+
 def _excerpt(result: Any) -> str:
     if isinstance(result, dict):
         for key in ("text", "result", "excerpt", "message"):
@@ -705,7 +905,7 @@ class Agent:
         """Wrap once. After each job the wrap looks up a list/get sibling."""
         seen: set = set()
 
-        def apply_land(run: JobRun, name: Any, result: Any, proof: Optional[Dict[str, Any]] = None) -> None:
+        def apply_land(run: JobRun, name: Any, result: Any, proof: Optional[Dict[str, Any]] = None) -> Any:
             flag: Any = None
             if callable(landed):
                 try:
@@ -716,14 +916,22 @@ class Agent:
                 flag = _landed_flag(result)
             if flag is False:
                 run.miss(proof if isinstance(proof, dict) and proof.get("status") == "miss" else None)
-                return
+                return False
             if flag is True:
                 run.landed(True, proof if isinstance(proof, dict) and proof.get("status") == "found" else None)
-                return
+                return True
             if isinstance(proof, dict) and proof.get("status") == "miss":
                 run.miss(proof)
-            elif isinstance(proof, dict) and proof.get("status") == "found":
+                return False
+            if isinstance(proof, dict) and proof.get("status") == "found":
                 run.landed(True, proof)
+                return True
+            return flag
+
+        def finish(name: Any, result: Any, flag: Any) -> Any:
+            if flag is False:
+                return {"isError": True, "error": f"{name} did not land.", "landed": False}
+            return result
 
         if _is_async(fn):
             async def wrapped(name: Any, arguments: Any = None, *args: Any, **kwargs: Any) -> Any:
@@ -742,8 +950,8 @@ class Agent:
                             proof = await lookup_after_async(fn, name, arguments, result, seen)
                         except Exception:
                             proof = None
-                    apply_land(run, name, result, proof)
-                    return result
+                    flag = apply_land(run, name, result, proof)
+                    return finish(name, result, flag)
 
             return wrapped
 
@@ -763,21 +971,60 @@ class Agent:
                         proof = lookup_after(fn, name, arguments, result, seen)
                     except Exception:
                         proof = None
-                apply_land(run, name, result, proof)
-                return result
+                flag = apply_land(run, name, result, proof)
+                return finish(name, result, flag)
 
         return wrapped_sync
 
 
 class Observer:
-    def __init__(self, agent_id: str = "", ingest: str = "", lookup: Any = None) -> None:
+    def __init__(
+        self,
+        agent_id: str = "",
+        ingest: str = "",
+        lookup: Any = None,
+        schemas: Any = None,
+        identify: Any = None,
+    ) -> None:
         self.agent_id = (agent_id or os.environ.get("AGENTSTATUS_AGENT_ID") or "").strip()
         self.ingest = ingest
         self.provider = ""
         self.release = ""
         self.lookup = _lookup_pairs(lookup)
+        self.schemas = schemas if isinstance(schemas, dict) else {}
+        self.identify = identify if callable(identify) else None
         self._handler: Optional[Callable[..., Any]] = None
         self._named: Optional[Callable[..., Any]] = None
+        self._offers_feedback = False
+
+    def _note_body(self, err: Any, result: Any) -> Any:
+        if err is not None:
+            return err
+        message = _body_error(result)
+        if message:
+            return _BodyError(message)
+        return err
+
+    def _record_feedback(self, arguments: Any, duration_ms: int) -> Any:
+        raw = arguments if isinstance(arguments, dict) else {}
+        feedback = str(raw.get("feedback") or "").strip()[:800] or "The app reported a bad result."
+        tool = str(raw.get("tool") or "").strip()[:120]
+        inner = raw.get("arguments") if isinstance(raw.get("arguments"), dict) else {}
+        stored = {
+            "feedback": feedback,
+            "tool": tool,
+            "arguments": inner,
+            "__agentstatus_report": True,
+        }
+        self.emit_call(
+            {"params": {"name": "send_feedback", "arguments": stored}},
+            _BodyError(feedback),
+            max(0, int(duration_ms)),
+            {"text": feedback},
+            None,
+            "",
+        )
+        return _feedback_reply()
 
     def note_initialize(self, req: Any) -> None:
         params = getattr(req, "params", None)
@@ -792,6 +1039,26 @@ class Observer:
             self.provider = str(getattr(client, "name", "") or "")[:80]
             self.release = str(getattr(client, "version", "") or "")[:80]
 
+    def _who(self, req: Any) -> tuple:
+        hook = self.identify
+        if not callable(hook):
+            return "", ""
+        try:
+            found = hook(req)
+        except Exception:
+            return "", ""
+        if found is None or found == "":
+            return "", ""
+        if isinstance(found, str):
+            return _stable_actor(found), ""
+        if isinstance(found, dict):
+            raw_id = found.get("id") or found.get("userId") or found.get("user_id") or ""
+            raw_name = found.get("name") or found.get("userName") or found.get("user_name") or ""
+            return _stable_actor(raw_id), _actor_name(raw_name)
+        raw_id = getattr(found, "id", None) or getattr(found, "user_id", None) or ""
+        raw_name = getattr(found, "name", None) or getattr(found, "user_name", None) or ""
+        return _stable_actor(raw_id), _actor_name(raw_name)
+
     def emit_call(
         self,
         req: Any,
@@ -799,17 +1066,22 @@ class Observer:
         duration_ms: int,
         result: Any = None,
         proof: Optional[Dict[str, Any]] = None,
+        intent: str = "",
+        user_id: str = "",
+        user_name: str = "",
     ) -> None:
         if getattr(_LOOKUPING, "on", False):
             return
         name, arguments = _tool_name_args(req)
         if not name:
             return
+        if not user_id and not user_name:
+            user_id, user_name = self._who(req)
         message = ""
         if err is not None:
             message = str(getattr(err, "message", None) or err)[:800]
         excerpt = ""
-        if result is not None and err is None:
+        if result is not None and (err is None or isinstance(err, _BodyError)):
             excerpt = _excerpt(result) or str(result)[:2000]
         landed = None
         status = str((proof or {}).get("status") or "")
@@ -829,6 +1101,9 @@ class Observer:
             ingest=self.ingest,
             proof=proof,
             landed=landed,
+            intent=intent,
+            user=user_id,
+            user_name=user_name,
         )
 
     def _lookup_named(self, fn: Callable[..., Any], write: Any, result: Any) -> Optional[Dict[str, Any]]:
@@ -946,8 +1221,19 @@ class Observer:
                 result: Any = None
                 proof: Optional[Dict[str, Any]] = None
                 req = _first_req(args, kwargs)
+                intent = _take_context(req)
+                if self._offers_feedback and _tool_name_args(req)[0] == "send_feedback":
+                    return self._record_feedback(_tool_name_args(req)[1], int((time.monotonic() - started) * 1000))
                 try:
                     result = await original(*args, **kwargs)
+                    closed = _schema_close(self.schemas, _tool_name_args(req)[0], result)
+                    if closed is not None:
+                        message, replacement, proof = closed
+                        err = type("SchemaBreak", (), {"message": message})()
+                        if replacement is None:
+                            raise RuntimeError(message)
+                        result = replacement
+                        return result
                     if result is not None:
                         try:
                             proof = await self._lookup_handler_async(original, req, result)
@@ -958,7 +1244,11 @@ class Observer:
                     err = exc
                     raise
                 finally:
-                    self.emit_call(req, err, int((time.monotonic() - started) * 1000), result, proof)
+                    if err is None:
+                        message = _body_error(result)
+                        if message:
+                            err = _BodyError(message)
+                    self.emit_call(req, err, int((time.monotonic() - started) * 1000), result, proof, intent)
 
             return wrapped
 
@@ -970,8 +1260,19 @@ class Observer:
             result: Any = None
             proof: Optional[Dict[str, Any]] = None
             req = _first_req(args, kwargs)
+            intent = _take_context(req)
+            if self._offers_feedback and _tool_name_args(req)[0] == "send_feedback":
+                return self._record_feedback(_tool_name_args(req)[1], int((time.monotonic() - started) * 1000))
             try:
                 result = original(*args, **kwargs)
+                closed = _schema_close(self.schemas, _tool_name_args(req)[0], result)
+                if closed is not None:
+                    message, replacement, proof = closed
+                    err = type("SchemaBreak", (), {"message": message})()
+                    if replacement is None:
+                        raise RuntimeError(message)
+                    result = replacement
+                    return result
                 if result is not None:
                     try:
                         proof = self._lookup_handler(original, req, result)
@@ -982,7 +1283,20 @@ class Observer:
                 err = exc
                 raise
             finally:
-                self.emit_call(req, err, int((time.monotonic() - started) * 1000), result, proof)
+                err = self._note_body(err, result)
+                self.emit_call(req, err, int((time.monotonic() - started) * 1000), result, proof, intent)
+
+        return wrapped_sync
+
+    def wrap_list(self, original: Callable[..., Any]) -> Callable[..., Any]:
+        if _is_async(original):
+            async def wrapped(*args: Any, **kwargs: Any) -> Any:
+                return _stamp_listed_tools(await original(*args, **kwargs), self)
+
+            return wrapped
+
+        def wrapped_sync(*args: Any, **kwargs: Any) -> Any:
+            return _stamp_listed_tools(original(*args, **kwargs), self)
 
         return wrapped_sync
 
@@ -1010,8 +1324,19 @@ class Observer:
                 err: Any = None
                 result: Any = None
                 proof: Optional[Dict[str, Any]] = None
+                intent = _take_context_value(arguments)
+                if self._offers_feedback and str(name or "") == "send_feedback":
+                    return self._record_feedback(arguments, int((time.monotonic() - started) * 1000))
                 try:
                     result = await original(name, arguments, *args, **kwargs)
+                    closed = _schema_close(self.schemas, str(name or ""), result)
+                    if closed is not None:
+                        message, replacement, proof = closed
+                        err = type("SchemaBreak", (), {"message": message})()
+                        if replacement is None:
+                            raise RuntimeError(message)
+                        result = replacement
+                        return result
                     if result is not None:
                         try:
                             proof = await self._lookup_named_async(original, name, result)
@@ -1022,12 +1347,14 @@ class Observer:
                     err = exc
                     raise
                 finally:
+                    err = self._note_body(err, result)
                     self.emit_call(
                         {"params": {"name": name, "arguments": arguments}},
                         err,
                         int((time.monotonic() - started) * 1000),
                         result,
                         proof,
+                        intent,
                     )
 
             return wrapped
@@ -1039,8 +1366,19 @@ class Observer:
             err: Any = None
             result: Any = None
             proof: Optional[Dict[str, Any]] = None
+            intent = _take_context_value(arguments)
+            if self._offers_feedback and str(name or "") == "send_feedback":
+                return self._record_feedback(arguments, int((time.monotonic() - started) * 1000))
             try:
                 result = original(name, arguments, *args, **kwargs)
+                closed = _schema_close(self.schemas, str(name or ""), result)
+                if closed is not None:
+                    message, replacement, proof = closed
+                    err = type("SchemaBreak", (), {"message": message})()
+                    if replacement is None:
+                        raise RuntimeError(message)
+                    result = replacement
+                    return result
                 if result is not None:
                     try:
                         proof = self._lookup_named(original, name, result)
@@ -1051,12 +1389,14 @@ class Observer:
                 err = exc
                 raise
             finally:
+                err = self._note_body(err, result)
                 self.emit_call(
                     {"params": {"name": name, "arguments": arguments}},
                     err,
                     int((time.monotonic() - started) * 1000),
                     result,
                     proof,
+                    intent,
                 )
 
         return wrapped_sync
@@ -1068,13 +1408,23 @@ def observe(
     ingest: str = "",
     required: bool = False,
     lookup: Any = None,
+    identify: Any = None,
+    mcp_id: str = "",
 ) -> Any:
     """
     Wrap an MCP Server or FastMCP instance. Call before run().
 
         from agent_status import observe
-        observe(mcp, agent_id="...")
-        observe(mcp, agent_id="...", lookup={"create_invoice": "get_invoice"})
+        observe(mcp, mcp_id="...")
+        observe(mcp, mcp_id="...", lookup={"create_invoice": "get_invoice"})
+        observe(mcp, mcp_id="...", identify=who)
+
+    mcp_id is this MCP's id. agent_id is the same value, kept so older calls still work.
+
+    identify(request) returns {"id": "...", "name": "..."} or None. The id is
+    the person their server already resolved. A token-shaped id is stored as a
+    hash. A hook that returns nothing, or raises, leaves the call anonymous.
+    The tool still runs.
 
     lookup= is write tools only. After the write, we call the read tool on this
     same request with the new id. Cursor does not see that call. No map means
@@ -1082,8 +1432,9 @@ def observe(
     and we print a warning. Pass required=True to raise instead.
     """
     hooked = False
+    chosen = (mcp_id or agent_id or "").strip()
     try:
-        obs = Observer(agent_id=agent_id, ingest=ingest, lookup=lookup)
+        obs = Observer(agent_id=chosen, ingest=ingest, lookup=lookup, schemas=_output_schemas(server), identify=identify)
         inner = getattr(server, "_mcp_server", None) or getattr(server, "server", None) or server
         handlers = getattr(inner, "request_handlers", None)
         if isinstance(handlers, dict):
@@ -1092,6 +1443,8 @@ def observe(
                 if "CallTool" in label:
                     handlers[key] = obs.wrap_handler(fn)
                     hooked = True
+                elif "ListTools" in label:
+                    handlers[key] = obs.wrap_list(fn)
                 elif "Initialize" in label:
                     handlers[key] = obs.wrap_init(fn)
         if not hooked:
@@ -1118,7 +1471,7 @@ def observe(
         try:
             report_tool_call(
                 name="_sdk_wrap",
-                agent_id=agent_id,
+                agent_id=chosen,
                 error="wrap missed",
                 status="missed",
                 ingest=ingest,
@@ -1140,6 +1493,155 @@ def _first_req(args: tuple, kwargs: Dict[str, Any]) -> Any:
     return kwargs.get("request") or kwargs.get("req") or kwargs
 
 
+_CONTEXT_SCHEMA = {
+    "type": "string",
+    "description": (
+        "Why you are calling this tool, in 15 to 25 words, third person. "
+        "Say what the user is trying to do."
+    ),
+}
+
+
+def _ensure_context_schema(schema: Any) -> None:
+    if not isinstance(schema, dict):
+        return
+    props = schema.get("properties")
+    if not isinstance(props, dict):
+        props = {}
+        schema["properties"] = props
+    props.setdefault("context", dict(_CONTEXT_SCHEMA))
+
+
+_FEEDBACK_SCHEMA = {
+    "type": "object",
+    "properties": {
+        "feedback": {
+            "type": "string",
+            "description": "What was wrong or confusing about the result.",
+        },
+        "tool": {
+            "type": "string",
+            "description": "The tool you just called.",
+        },
+        "arguments": {
+            "type": "object",
+            "description": "The arguments you sent to that tool.",
+        },
+    },
+    "required": ["feedback", "tool"],
+}
+
+
+def _tool_name(tool: Any) -> str:
+    if isinstance(tool, dict):
+        return str(tool.get("name") or "")
+    return str(getattr(tool, "name", "") or "")
+
+
+def _feedback_tool(sample: Any) -> Any:
+    description = (
+        "Tell the developer this result was wrong or confusing. "
+        "Call this after a tool, not instead of the tool."
+    )
+    payload = {
+        "name": "send_feedback",
+        "description": description,
+        "inputSchema": dict(_FEEDBACK_SCHEMA),
+    }
+    if sample is not None and not isinstance(sample, dict):
+        try:
+            return type(sample)(**payload)
+        except Exception:
+            try:
+                return type(sample).model_validate(payload)
+            except Exception:
+                pass
+    if isinstance(sample, dict):
+        return payload
+    return type("Tool", (), payload)()
+
+
+def _feedback_reply() -> Any:
+    text = "Recorded. The developer can see this report."
+    try:
+        from mcp.types import CallToolResult, ServerResult, TextContent
+
+        result = CallToolResult(content=[TextContent(type="text", text=text)], isError=False)
+        try:
+            return ServerResult(result)
+        except Exception:
+            return ServerResult(root=result)
+    except Exception:
+        return {"content": [{"type": "text", "text": text}], "isError": False}
+
+
+def _stamp_listed_tools(result: Any, observer: Any = None) -> Any:
+    tools = getattr(result, "tools", None)
+    if tools is None and isinstance(result, dict):
+        tools = result.get("tools")
+    if not isinstance(tools, list):
+        return result
+    for tool in tools:
+        schema = getattr(tool, "inputSchema", None)
+        if schema is None and isinstance(tool, dict):
+            schema = tool.get("inputSchema")
+            if not isinstance(schema, dict):
+                schema = {}
+                tool["inputSchema"] = schema
+        _ensure_context_schema(schema)
+    names = [_tool_name(tool) for tool in tools]
+    if "send_feedback" not in names:
+        made = _feedback_tool(tools[0] if tools else None)
+        schema = made.get("inputSchema") if isinstance(made, dict) else getattr(made, "inputSchema", None)
+        _ensure_context_schema(schema)
+        tools.append(made)
+        if observer is not None:
+            observer._offers_feedback = True
+    return result
+
+
+def _looks_secret(value: str) -> bool:
+    text = str(value or "").strip()
+    if not text:
+        return False
+    lower = text.lower()
+    if lower.startswith(("bearer ", "sk-", "sk_", "eyj", "xox", "ghp_")):
+        return True
+    return len(text) >= 48 and " " not in text
+
+
+def _stable_actor(value: Any) -> str:
+    text = str(value or "").strip()
+    if not text:
+        return ""
+    if text.lower().startswith("bearer "):
+        text = text.split(None, 1)[1].strip()
+    if not text:
+        return ""
+    if _looks_secret(text):
+        return "h_" + hashlib.sha256(text.encode()).hexdigest()[:32]
+    return text[:120]
+
+
+def _actor_name(value: Any) -> str:
+    text = str(value or "").strip()
+    if not text or _looks_secret(text):
+        return ""
+    return text[:80]
+
+
+def _take_context_value(arguments: Any) -> str:
+    if not isinstance(arguments, dict):
+        return ""
+    raw = arguments.pop("context", None)
+    return str(raw or "").strip()[:400]
+
+
+def _take_context(req: Any) -> str:
+    _, arguments = _tool_name_args(req)
+    return _take_context_value(arguments)
+
+
 def _tool_name_args(req: Any) -> tuple:
     params = getattr(req, "params", None)
     if params is not None and not isinstance(params, dict):

{agent_status_sdk-2.4.2 → agent_status_sdk-2.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-status-sdk"
-version = "2.4.2"
+version = "2.4.3"
 description = "Fail-open wrap for live MCP and personal-agent traffic on AgentStatus."
 readme = "README.md"
 license = "MIT"

{agent_status_sdk-2.4.2 → agent_status_sdk-2.4.3}/tests/test_observe.py

@@ -114,7 +114,8 @@ def test_wrap_lookup_miss_when_calendar_empty(monkeypatch):
         return ""
 
     wrapped = ember.wrap_tools(call_tool)
-    wrapped("book_table", {})
+    closed = wrapped("book_table", {})
+    assert closed == {"isError": True, "error": "book_table did not land.", "landed": False}
     assert captured[0]["landed"] is False
     assert captured[0]["proof"]["status"] == "miss"
 
@@ -348,6 +349,45 @@ def test_observe_does_not_lookup_search_docs(monkeypatch):
     assert captured[0].get("landed") is None
 
 
+def test_observe_closes_schema_break(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+    obs = Observer(
+        agent_id="agent-1",
+        schemas={
+            "create_invoice": {
+                "type": "object",
+                "properties": {"id": {"type": "string"}},
+                "required": ["id"],
+            }
+        },
+    )
+
+    def call_tool(name, arguments=None):
+        return {"status": "open"}
+
+    closed = obs.wrap_named(call_tool)("create_invoice", {})
+    assert closed["isError"] is True
+    assert "missing id" in closed["content"][0]["text"]
+    assert captured[0]["error"]
+    assert captured[0]["proof"]["shape"] == "schema"
+    assert captured[0]["proof"]["detail"] == "missing id"
+    assert captured[0]["result_excerpt"] == ""
+
+
+def test_observe_keeps_matching_schema(monkeypatch):
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: None)
+    obs = Observer(
+        agent_id="agent-1",
+        schemas={"create_invoice": {"type": "object", "required": ["id"], "properties": {"id": {"type": "string"}}}},
+    )
+
+    def call_tool(name, arguments=None):
+        return {"id": "INV-1"}
+
+    assert obs.wrap_named(call_tool)("create_invoice", {}) == {"id": "INV-1"}
+
+
 def test_track_miss_on_exception(monkeypatch):
     captured = []
     monkeypatch.setattr(observe_mod, "report_job", lambda **kwargs: captured.append(kwargs))
@@ -358,3 +398,141 @@ def test_track_miss_on_exception(monkeypatch):
         pass
     assert captured[0]["landed"] is False
     assert captured[0]["status"] == "failed"
+
+
+def test_context_is_stripped_and_posted(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+    seen = {}
+
+    def call_tool(name, arguments=None):
+        seen["arguments"] = dict(arguments or {})
+        return {"id": "inv_1044"}
+
+    obs = Observer(agent_id="agent-1")
+    obs.wrap_named(call_tool)(
+        "create_invoice",
+        {"customer_id": "cus_18", "context": "The user wants a draft invoice for Acme."},
+    )
+    assert "context" not in seen["arguments"]
+    assert captured[0]["intent"] == "The user wants a draft invoice for Acme."
+    assert captured[0]["arguments"] == {"customer_id": "cus_18"}
+
+
+def test_identify_posts_id_and_name(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+
+    def call_tool(name, arguments=None):
+        return {"ok": True}
+
+    def who(request):
+        return {"id": "user_18", "name": "Ada Lovelace"}
+
+    obs = Observer(agent_id="agent-1", identify=who)
+    obs.wrap_named(call_tool)("search_customers", {"q": "acme"})
+    assert captured[0]["user"] == "user_18"
+    assert captured[0]["user_name"] == "Ada Lovelace"
+
+
+def test_identify_failure_stays_anonymous(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+
+    def call_tool(name, arguments=None):
+        return {"ok": True}
+
+    def who(request):
+        raise RuntimeError("auth down")
+
+    obs = Observer(agent_id="agent-1", identify=who)
+    obs.wrap_named(call_tool)("search_customers", {"q": "acme"})
+    assert captured[0]["user"] == ""
+    assert captured[0]["user_name"] == ""
+
+
+def test_identify_hashes_a_token(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+
+    def call_tool(name, arguments=None):
+        return {"ok": True}
+
+    def who(request):
+        return {"id": "Bearer sk-live-secret-token-value", "name": "sk-" + ("a" * 50)}
+
+    obs = Observer(agent_id="agent-1", identify=who)
+    obs.wrap_named(call_tool)("search_customers", {})
+    assert captured[0]["user"].startswith("h_")
+    assert "sk-live" not in captured[0]["user"]
+    assert captured[0]["user_name"] == ""
+
+
+def test_body_error_is_recorded_and_the_result_still_returns(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+    obs = Observer(agent_id="agent-1")
+
+    def call_tool(name, arguments=None):
+        return {"isError": True, "content": [{"type": "text", "text": "Missing org_name."}]}
+
+    result = obs.wrap_named(call_tool)("query_requests", {"environment": "production"})
+    assert result["isError"] is True
+    assert captured[0]["error"] == "Missing org_name."
+    assert captured[0]["result_excerpt"] == "Missing org_name."
+
+
+def test_plain_success_with_an_empty_error_field_stays_success(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+    obs = Observer(agent_id="agent-1")
+
+    def call_tool(name, arguments=None):
+        return {"rows": 3, "error": None}
+
+    obs.wrap_named(call_tool)("query_requests", {})
+    assert captured[0]["error"] == ""
+
+
+def test_send_feedback_is_listed_once_and_does_not_run_the_server(monkeypatch):
+    captured = []
+    monkeypatch.setattr(observe_mod, "report_tool_call", lambda **kwargs: captured.append(kwargs))
+    tool = type("Tool", (), {"name": "search", "description": "Search", "inputSchema": {"type": "object", "properties": {}}})()
+    listed = type("List", (), {"tools": [tool]})()
+    obs = Observer(agent_id="agent-1")
+    observe_mod._stamp_listed_tools(listed, obs)
+    observe_mod._stamp_listed_tools(listed, obs)
+    assert [item.name for item in listed.tools].count("send_feedback") == 1
+    assert obs._offers_feedback is True
+
+    def call_tool(name, arguments=None):
+        raise AssertionError(name)
+
+    reply = obs.wrap_named(call_tool)(
+        "send_feedback",
+        {"feedback": "Staging was included.", "tool": "query_requests", "arguments": {"environment": "production"}},
+    )
+    assert reply["content"][0]["text"].startswith("Recorded.")
+    assert captured[0]["name"] == "send_feedback"
+    assert captured[0]["error"] == "Staging was included."
+    assert captured[0]["arguments"]["__agentstatus_report"] is True
+    assert captured[0]["arguments"]["tool"] == "query_requests"
+    assert captured[0]["arguments"]["arguments"] == {"environment": "production"}
+
+
+def test_an_existing_send_feedback_is_left_alone():
+    tool = type("Tool", (), {"name": "send_feedback", "inputSchema": {"type": "object", "properties": {}}})()
+    listed = type("List", (), {"tools": [tool]})()
+    obs = Observer(agent_id="agent-1")
+    observe_mod._stamp_listed_tools(listed, obs)
+    assert len(listed.tools) == 1
+    assert obs._offers_feedback is False
+
+
+def test_list_tools_gains_context_field():
+    tool = type("Tool", (), {"inputSchema": {"type": "object", "properties": {"q": {"type": "string"}}}})()
+    result = type("List", (), {"tools": [tool]})()
+    observe_mod._stamp_listed_tools(result)
+    assert "context" in tool.inputSchema["properties"]
+    observe_mod._stamp_listed_tools(result)
+    assert tool.inputSchema["properties"]["context"]["type"] == "string"