mcpsignals 2.3.2__tar.gz → 2.5.0__tar.gz

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpsignals
-Version: 2.3.2
+Version: 2.5.0
 Summary: Drop-in instrumentation for MCP servers. Writes tool-call events to a database you own.
 Project-URL: Homepage, https://github.com/zentered-studios/mcpsignals#readme
 Project-URL: Repository, https://github.com/zentered-studios/mcpsignals
@@ -60,8 +60,9 @@ def search(query: str) -> str:
 Call `instrument()` any time before the server starts handling requests. It
 appends to `server.middleware`, and that chain is rebuilt from the live list
 on every request, so calling it before or after your `@server.tool()`
-definitions makes no difference. The Node.js package differs here: it wraps
-`registerTool`, so it has to run before any tool is registered.
+definitions makes no difference. The Node.js package differs here: it reads
+tool annotations and intent capture from wrapping `registerTool`, so it has
+to run before any tool is registered.
 
 With no sink configured it writes JSON lines to stdout. On a stdio
 transport pass `sinks=[ConsoleSink(stream=sys.stderr)]`, because the MCP
@@ -190,16 +191,13 @@ interval mode, `close()` is also what stops the interval task and removes the
 accumulate either. Both `flush()` and `close()` are safe to await more than
 once.
 
-## Known limitation: `session_id`
+## `session_id`
 
-`mcp` 2.0.0's middleware-facing `ServerRequestContext` does not publicly
-expose the transport's connection-level session id (only the
-handler-facing `Context` class does, via a private accessor middleware
-doesn't have). `session_id` on emitted events is therefore only ever
-populated when intent capture is enabled and the calling agent supplies
-one - not from the underlying transport connection. See `instrument.py`
-for details; this will be revisited if/when upstream exposes it to
-middleware.
+On a stateful streamable HTTP connection, `session_id` is the
+`Mcp-Session-Id` header the client sends with every request after
+`initialize`. It wins over a `session_id` the calling agent supplies through
+intent capture. On stdio there is no transport session, so `session_id` is
+only set when intent capture is enabled and the agent supplies one.
 
 ## Full docs
 

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/README.md

@@ -34,8 +34,9 @@ def search(query: str) -> str:
 Call `instrument()` any time before the server starts handling requests. It
 appends to `server.middleware`, and that chain is rebuilt from the live list
 on every request, so calling it before or after your `@server.tool()`
-definitions makes no difference. The Node.js package differs here: it wraps
-`registerTool`, so it has to run before any tool is registered.
+definitions makes no difference. The Node.js package differs here: it reads
+tool annotations and intent capture from wrapping `registerTool`, so it has
+to run before any tool is registered.
 
 With no sink configured it writes JSON lines to stdout. On a stdio
 transport pass `sinks=[ConsoleSink(stream=sys.stderr)]`, because the MCP
@@ -164,16 +165,13 @@ interval mode, `close()` is also what stops the interval task and removes the
 accumulate either. Both `flush()` and `close()` are safe to await more than
 once.
 
-## Known limitation: `session_id`
+## `session_id`
 
-`mcp` 2.0.0's middleware-facing `ServerRequestContext` does not publicly
-expose the transport's connection-level session id (only the
-handler-facing `Context` class does, via a private accessor middleware
-doesn't have). `session_id` on emitted events is therefore only ever
-populated when intent capture is enabled and the calling agent supplies
-one - not from the underlying transport connection. See `instrument.py`
-for details; this will be revisited if/when upstream exposes it to
-middleware.
+On a stateful streamable HTTP connection, `session_id` is the
+`Mcp-Session-Id` header the client sends with every request after
+`initialize`. It wins over a `session_id` the calling agent supplies through
+intent capture. On stdio there is no transport session, so `session_id` is
+only set when intent capture is enabled and the agent supplies one.
 
 ## Full docs
 

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/pyproject.toml

@@ -8,7 +8,7 @@ name = "mcpsignals"
 # stamps the real version in at release time and never commits it back, exactly
 # as packages/node/package.json is left at 0.1.0. Do not read this as the
 # published version - check PyPI or the git tags for that.
-version = "2.3.2"
+version = "2.5.0"
 description = "Drop-in instrumentation for MCP servers. Writes tool-call events to a database you own."
 readme = "README.md"
 license = "MIT"

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/__init__.py

@@ -1,9 +1,14 @@
-from mcpsignals.events import ToolCallEvent
+from mcpsignals.error_kind import is_error_kind
+from mcpsignals.events import ERROR_KIND_META_KEY, ERROR_KINDS, ErrorKind, ToolCallEvent
 from mcpsignals.handle import InstrumentHandle, handle_for
 from mcpsignals.instrument import instrument
 from mcpsignals.redaction import RedactionConfig
 
 __all__ = [
+    "ERROR_KINDS",
+    "ERROR_KIND_META_KEY",
+    "ErrorKind",
+    "is_error_kind",
     "instrument",
     "handle_for",
     "InstrumentHandle",

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/error_kind.py

@@ -4,13 +4,21 @@ the documented false-positive mode.
 """
 
 import re
+from typing import Any
+
+from mcpsignals.events import ERROR_KINDS, ErrorKind
 
 _NOT_FOUND = re.compile(r"not found|does not exist|no such", re.IGNORECASE)
 _EMPTY = re.compile(r"\bempty\b|no results?|nothing found|zero results", re.IGNORECASE)
 _VALIDATION = re.compile(r"invalid|required|expected|must be|validation|schema", re.IGNORECASE)
 
 
-def classify_error(message: str | None) -> str | None:
+def is_error_kind(value: Any) -> bool:
+    """True when `value` is one of `ERROR_KINDS`."""
+    return isinstance(value, str) and value in ERROR_KINDS
+
+
+def classify_error(message: str | None) -> ErrorKind | None:
     """Bucket an error message into not_found / empty / validation / internal.
 
     Returns None when there is no message to classify (i.e. the call succeeded).

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/events.py

@@ -2,7 +2,27 @@
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Literal
+from typing import Any, Literal, get_args
+
+#: Every value `error_kind` can take. `classify_error` only produces some of
+#: them; see schema/events.md.
+ErrorKind = Literal[
+    "not_found",
+    "empty",
+    "validation",
+    "auth_required",
+    "payment_required",
+    "internal",
+]
+ERROR_KINDS: tuple[ErrorKind, ...] = get_args(ErrorKind)
+
+#: A `tools/call` result's `resultType` (protocol revision 2026-07-28).
+#: Older revisions only ever produce `complete`.
+ResultType = Literal["complete", "input_required"]
+
+#: `_meta` key a tool handler sets on an `isError` result to record the
+#: `error_kind` it already knows, instead of relying on `classify_error`.
+ERROR_KIND_META_KEY = "mcpsignals/error_kind"
 
 
 @dataclass
@@ -20,13 +40,21 @@ class ToolCallEvent:
     org_id: str | None = None
     duration_ms: int = 0
     success: bool = True
-    error_kind: str | None = None
+    error_kind: ErrorKind | None = None
     error_message: str | None = None
     request_bytes: int = 0
     response_bytes: int = 0
     arguments: dict[str, Any] | None = None
     intent: str | None = None
     transport: str | None = None
+    protocol_version: str | None = None
+    request_id: str | None = None
+    trace_id: str | None = None
+    parent_span_id: str | None = None
+    result_type: ResultType | None = None
+    error_code: int | None = None
+    read_only_hint: bool | None = None
+    destructive_hint: bool | None = None
 
 
 #: What a sink receives. There is one event type today, so this is an alias

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/instrument.py

@@ -5,19 +5,13 @@ present on both `MCPServer` and the low-level `Server` - the same mechanism
 works for both, no separate code paths needed. See
 https://py.sdk.modelcontextprotocol.io/v2/advanced/middleware/.
 
-Known SDK limitation (first verified against mcp==2.0.0, re-checked against
-the mcp==2.2.0 that a fresh `uv sync` resolves; mcp/server/context.py):
-`ServerRequestContext` - what middleware receives - does not publicly expose
-the transport's connection-level session id or a `connection` accessor
-(only the handler-facing `Context` class does, via a private `Connection`
-it doesn't share with middleware; `ctx.session` is a `ServerSession`, which
-has no session id either). We do not reach into that private attribute. As
-a result `session_id` on emitted events is only ever populated from the
-optional intent-capture value the calling agent supplies - it is `None` for
-calls where intent capture is off or the caller didn't pass one, even though
-the connection may well have a real session id.
-Track https://github.com/modelcontextprotocol/python-sdk for this being
-exposed to middleware in a future release.
+`session_id`: `ServerRequestContext` - what middleware receives - has no
+session id accessor (verified against mcp==2.2.0; mcp/server/context.py).
+It does carry the HTTP request on the streamable HTTP path, so the
+middleware reads the `Mcp-Session-Id` header the client echoes back on
+every request after `initialize`. On stdio there is no transport session,
+and `session_id` comes only from the optional intent-capture value the
+calling agent supplies.
 
 Guarantee: nothing the library does around a tool call can change what the
 client receives. The real handler always runs, its result is returned
@@ -31,6 +25,7 @@ arguments. A sink failure is handled separately by EventBuffer, also logged
 once per sink.
 """
 
+import asyncio
 import inspect
 import json
 import logging
@@ -40,9 +35,13 @@ from dataclasses import replace
 from datetime import datetime, timezone
 from typing import Any
 
+from mcp.server.mcpserver import MCPServer
+from mcp.shared.exceptions import MCPError
+from pydantic import ValidationError
+
 from mcpsignals.buffer import EventBuffer
-from mcpsignals.error_kind import classify_error
-from mcpsignals.events import ToolCallEvent
+from mcpsignals.error_kind import classify_error, is_error_kind
+from mcpsignals.events import ERROR_KIND_META_KEY, ErrorKind, ResultType, ToolCallEvent
 from mcpsignals.handle import InstrumentHandle
 from mcpsignals.handle import register as _register_handle
 from mcpsignals.intent_capture import (
@@ -55,6 +54,13 @@ from mcpsignals.intent_capture import (
 from mcpsignals.redaction import RedactionConfig, redact_arguments
 from mcpsignals.sinks.base import Sink
 from mcpsignals.sinks.console import ConsoleSink
+from mcpsignals.trace_context import parse_traceparent
+
+#: JSON-RPC's code for invalid params, which the SDK answers a pydantic
+#: `ValidationError` with.
+_INVALID_PARAMS = -32602
+
+ToolHints = tuple[bool | None, bool | None]
 
 logger = logging.getLogger("mcpsignals")
 
@@ -78,6 +84,19 @@ def _result_content(result: Any) -> Any:
     return getattr(result, "content", None)
 
 
+def _declared_error_kind(result: Any) -> ErrorKind | None:
+    """The `error_kind` a handler set in the result's `_meta`, if it is a known value."""
+    # Same two shapes as `_is_error_result`: wire-shaped (`_meta`) or snake_case (`meta`).
+    if isinstance(result, Mapping):
+        meta = result.get("_meta")
+        if meta is None:
+            meta = result.get("meta")
+    else:
+        meta = getattr(result, "meta", None)
+    kind = meta.get(ERROR_KIND_META_KEY) if isinstance(meta, Mapping) else None
+    return kind if is_error_kind(kind) else None
+
+
 def _content_to_text(content: Any) -> str | None:
     if not content:
         return None
@@ -89,6 +108,56 @@ def _content_to_text(content: Any) -> str | None:
     return "\n".join(parts) if parts else None
 
 
+def _result_type(result: Any) -> ResultType:
+    """`input_required` for a 2026-07-28 multi-round-trip result, else `complete`."""
+    if isinstance(result, Mapping):
+        value = result.get("resultType", result.get("result_type"))
+    else:
+        value = getattr(result, "result_type", None)
+    return "input_required" if value == "input_required" else "complete"
+
+
+def _error_code(exc: BaseException) -> int | None:
+    """The JSON-RPC code the SDK answers `exc` with, where every transport
+    agrees on it. Any other exception is answered with a code that depends on
+    the transport (0 or -32603), so it is recorded as None."""
+    if isinstance(exc, MCPError):
+        return exc.error.code
+    if isinstance(exc, ValidationError):
+        return _INVALID_PARAMS
+    return None
+
+
+def _as_bool(value: Any) -> bool | None:
+    return value if isinstance(value, bool) else None
+
+
+def _tool_hints(tool: Any) -> tuple[str | None, ToolHints]:
+    """A `tools/list` entry's name and its read-only / destructive hints.
+    Handles the wire dict (camelCase) and the `Tool` model (snake_case)."""
+    if isinstance(tool, Mapping):
+        name = tool.get("name")
+        annotations = tool.get("annotations")
+    else:
+        name = getattr(tool, "name", None)
+        annotations = getattr(tool, "annotations", None)
+    if isinstance(annotations, Mapping):
+        read_only = annotations.get("readOnlyHint", annotations.get("read_only_hint"))
+        destructive = annotations.get("destructiveHint", annotations.get("destructive_hint"))
+    else:
+        read_only = getattr(annotations, "read_only_hint", None)
+        destructive = getattr(annotations, "destructive_hint", None)
+    return (name if isinstance(name, str) else None), (_as_bool(read_only), _as_bool(destructive))
+
+
+def _session_id_header(request: Any) -> str | None:
+    """The `Mcp-Session-Id` header of an HTTP request, capped, or None."""
+    headers = getattr(request, "headers", None)
+    if headers is None:
+        return None
+    return bounded(headers.get("mcp-session-id"), MAX_IDENTIFIER_LENGTH) or None
+
+
 def _serialize_for_bytes(value: Any) -> bytes:
     if value is None:
         return b""
@@ -143,9 +212,75 @@ def instrument(
             exc,
         )
 
+    # Tool name -> (read_only_hint, destructive_hint). Middleware sees only the
+    # request, not the registration, so hints come from the `tools/list`
+    # results passing through. On `MCPServer`, the first miss also lists the
+    # server's tools once; a name still missing after that is unknown and is
+    # not listed again. `add_tool` and `remove_tool` clear the cache, so a tool
+    # re-added with other annotations is read fresh. On a low-level `Server`
+    # the hints are null until the client calls `tools/list`.
+    tool_hints: dict[str, ToolHints] = {}
+    # The one listing since the last registration change. Concurrent misses
+    # await the same task, so none of them reads a half-filled cache.
+    listing: asyncio.Task[None] | None = None
+
+    def _remember_hints(tools: Any) -> None:
+        for tool in tools or []:
+            name, hints = _tool_hints(tool)
+            if name is not None:
+                tool_hints[name] = hints
+
+    async def _list_hints() -> None:
+        tools = await server.list_tools()
+        # A registration change while this ran makes the result stale.
+        if listing is asyncio.current_task():
+            _remember_hints(tools)
+
+    async def _hints_for(name: str) -> ToolHints:
+        nonlocal listing
+        if name not in tool_hints and isinstance(server, MCPServer):
+            if listing is None:
+                listing = asyncio.ensure_future(_list_hints())
+            task = listing
+            try:
+                # Shielded: a cancelled call must not cancel the shared listing.
+                await asyncio.shield(task)
+            except Exception:
+                # A failed listing is retried on the next miss.
+                if listing is task:
+                    listing = None
+                raise
+        return tool_hints.get(name, (None, None))
+
+    def _forget_hints() -> None:
+        nonlocal listing
+        tool_hints.clear()
+        listing = None
+
+    if isinstance(server, MCPServer):
+        # `@server.tool()` registers through `add_tool`, so this sees every change.
+        for method_name in ("add_tool", "remove_tool"):
+            original = getattr(server, method_name)
+
+            def _invalidating(*args: Any, _original: Any = original, **kwargs: Any) -> Any:
+                result = _original(*args, **kwargs)
+                _forget_hints()
+                return result
+
+            setattr(server, method_name, _invalidating)
+
     async def _mcpsignals_middleware(ctx, call_next):
         if ctx.method == "tools/list":
             result = await call_next(ctx)
+            try:
+                tools = (
+                    result.get("tools")
+                    if isinstance(result, Mapping)
+                    else getattr(result, "tools", None)
+                )
+                _remember_hints(tools)
+            except Exception as exc:  # noqa: BLE001 - never changes the tools/list result
+                _warn_once("tool hints", exc)
             if intent_capture or intent_capture_tools:
                 # `call_next` returns a wire-shaped dict here (camelCase keys),
                 # not a ListToolsResult/Tool instance - verified against the
@@ -218,7 +353,25 @@ def instrument(
             client_name = bounded(client_info.name, MAX_IDENTIFIER_LENGTH)
             client_version = bounded(client_info.version, MAX_IDENTIFIER_LENGTH)
 
-        transport = "http" if getattr(ctx, "request", None) is not None else "stdio"
+        http_request = getattr(ctx, "request", None)
+        transport = "http" if http_request is not None else "stdio"
+        # The transport's session: the `Mcp-Session-Id` header a stateful
+        # streamable HTTP client echoes back on every request. A stateless
+        # server accepts any value here, so it takes the identifier cap.
+        transport_session_id = _session_id_header(http_request)
+
+        # Revision 2026-07-28 carries the version on every request's envelope;
+        # earlier revisions negotiate it in `initialize`. Either way the client
+        # supplied it, so it takes the identifier cap, as does the request id.
+        protocol_version = bounded(getattr(ctx, "protocol_version", None), MAX_IDENTIFIER_LENGTH)
+        request_id = getattr(ctx, "request_id", None)
+        request_id = (
+            bounded(str(request_id), MAX_IDENTIFIER_LENGTH)
+            if isinstance(request_id, (str, int)) and not isinstance(request_id, bool)
+            else None
+        )
+        meta = getattr(ctx, "meta", None)
+        trace = parse_traceparent(meta.get("traceparent") if isinstance(meta, Mapping) else None)
 
         async def _record(ts: datetime, error: BaseException | None, result: Any) -> None:
             # First thing: the handler has just settled, so this is the
@@ -227,8 +380,9 @@ def instrument(
             duration_ms = int((time.perf_counter() - start) * 1000)
 
             # Runs after the handler so its latency never lands in
-            # `duration_ms`. A host resolver that raises records a null
-            # identity; the handler's result is already on its way back.
+            # `duration_ms`. It still runs before the result is returned, so
+            # the client waits for it. A host resolver that raises records a
+            # null identity.
             user_id: str | None = None
             org_id: str | None = None
             if resolve_identity is not None:
@@ -242,15 +396,36 @@ def instrument(
                     _warn_once("resolve_identity", exc)
                     user_id, org_id = None, None
 
+            # After the timed window too. The first miss after a registration
+            # change lists the server's tools, and the client waits for that one.
+            try:
+                read_only_hint, destructive_hint = await _hints_for(raw_tool_name)
+            except Exception as exc:  # noqa: BLE001 - a hint lookup never costs the event
+                _warn_once("tool hints", exc)
+                read_only_hint, destructive_hint = None, None
+
+            declared_kind: ErrorKind | None = None
+            result_type: ResultType | None = None
+            error_code: int | None = None
             if error is not None:
                 success = False
                 error_message: str | None = str(error)[:2000]
                 response_bytes = 0
+                error_code = _error_code(error)
             else:
+                result_type = _result_type(result)
                 success = not _is_error_result(result)
                 error_message = None if success else _content_to_text(_result_content(result))
                 if error_message:
                     error_message = error_message[:2000]
+                # A kind the handler declared wins; an unknown value falls back to the heuristic.
+                # Guarded on its own so a throwing `_meta` costs only the
+                # declared kind, not the event.
+                if not success:
+                    try:
+                        declared_kind = _declared_error_kind(result)
+                    except Exception as exc:
+                        _warn_once("declared error kind", exc)
                 response_bytes = len(_serialize_for_bytes(result))
 
             # Guarded on its own so a broken redactor still leaves an event
@@ -283,7 +458,7 @@ def instrument(
                 server_name=server_name,
                 server_version=server_version,
                 tool_name=tool_name,
-                session_id=extracted.get("session_id"),
+                session_id=transport_session_id or extracted.get("session_id"),
                 agent_id=extracted.get("agent_id"),
                 client_name=client_name,
                 client_version=client_version,
@@ -291,13 +466,21 @@ def instrument(
                 org_id=org_id,
                 duration_ms=duration_ms,
                 success=success,
-                error_kind=classify_error(error_message),
+                error_kind=declared_kind or classify_error(error_message),
                 error_message=error_message,
                 request_bytes=request_bytes,
                 response_bytes=response_bytes,
                 arguments=arguments,
                 intent=extracted.get("intent"),
                 transport=transport,
+                protocol_version=protocol_version,
+                request_id=request_id,
+                trace_id=trace[0] if trace else None,
+                parent_span_id=trace[1] if trace else None,
+                result_type=result_type,
+                error_code=error_code,
+                read_only_hint=read_only_hint,
+                destructive_hint=destructive_hint,
             )
             await buffer.add(event)
 

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/sinks/otlp.py

@@ -1,15 +1,16 @@
 """OTLP sink. Requires the `otlp` extra (opentelemetry-api only, not an SDK
 or exporter - relies on whatever global TracerProvider the host app already
-configured, the standard "zero-code" OTel pattern). Emits one root span per
-tool call; spans are never parented to the context current at flush time
-(see the note at `start_span` in `write`).
+configured, the standard "zero-code" OTel pattern). Emits one span per tool
+call: a child of the caller's span when the request carried a `traceparent`,
+a root span otherwise. Spans are never parented to the context current at
+flush time (see the note at `start_span` in `write`).
 
 Field mapping verified against the live OpenTelemetry GenAI semantic
 conventions for MCP (open-telemetry/semantic-conventions-genai,
 docs/gen-ai/mcp.md) as of this writing. Everything in that document is
 Development/Experimental status, not Stable, except where noted below.
 Where our schema has no equivalent convention, we use a custom
-`mcpsignals.*` attribute rather than force a bad fit (see `transport`).
+`mcpsignals.*` attribute rather than force a bad fit.
 """
 
 import json
@@ -17,6 +18,17 @@ import json
 from mcpsignals.events import ToolCallEvent
 
 
+def _network_attributes(transport: str | None) -> dict[str, str]:
+    """The MCP semconv's "Recording MCP transport" table: stdio is `pipe`,
+    streamable HTTP is `tcp` with `network.protocol.name` `http`. The
+    original value also stays on `mcpsignals.transport`."""
+    if transport == "stdio":
+        return {"network.transport": "pipe"}
+    if transport == "http":
+        return {"network.transport": "tcp", "network.protocol.name": "http"}
+    return {}
+
+
 class OtlpSink:
     def __init__(self, tracer=None):
         if tracer is None:
@@ -27,12 +39,22 @@ class OtlpSink:
 
     async def write(self, events: list[ToolCallEvent]) -> None:
         from opentelemetry.context import Context
-        from opentelemetry.trace import SpanKind, Status, StatusCode
+        from opentelemetry.trace import (
+            NonRecordingSpan,
+            SpanContext,
+            SpanKind,
+            Status,
+            StatusCode,
+            TraceFlags,
+            set_span_in_context,
+        )
 
         for event in events:
             attributes = {
+                "mcp.method.name": "tools/call",
                 "gen_ai.operation.name": "execute_tool",
                 "gen_ai.tool.name": event.tool_name,
+                **_network_attributes(event.transport),
                 "mcpsignals.server.name": event.server_name,
                 "mcpsignals.request.bytes": event.request_bytes,
                 "mcpsignals.response.bytes": event.response_bytes,
@@ -54,11 +76,27 @@ class OtlpSink:
             if event.org_id:
                 attributes["mcpsignals.org.id"] = event.org_id
             if event.transport:
-                # Deliberately NOT network.transport: that attribute's vocabulary
-                # (tcp/udp/quic/pipe/unix) does not fit MCP's stdio/http.
                 attributes["mcpsignals.transport"] = event.transport
             if event.intent:
                 attributes["mcpsignals.intent"] = event.intent
+            if not event.success:
+                # A JSON-RPC error's code, else the semconv value for an
+                # `isError` tool result. Same as the Node sink.
+                if event.error_code is not None:
+                    attributes["error.type"] = str(event.error_code)
+                    attributes["rpc.response.status_code"] = str(event.error_code)
+                else:
+                    attributes["error.type"] = "tool_error"
+            if event.protocol_version:
+                attributes["mcp.protocol.version"] = event.protocol_version
+            if event.request_id:
+                attributes["jsonrpc.request.id"] = event.request_id
+            if event.result_type:
+                attributes["mcpsignals.result.type"] = event.result_type
+            if event.read_only_hint is not None:
+                attributes["mcpsignals.tool.read_only_hint"] = event.read_only_hint
+            if event.destructive_hint is not None:
+                attributes["mcpsignals.tool.destructive_hint"] = event.destructive_hint
             if event.error_kind:
                 attributes["mcpsignals.error.kind"] = event.error_kind
             if event.arguments is not None:
@@ -74,10 +112,26 @@ class OtlpSink:
             # The batch is usually written from inside whatever request handler
             # pushed the last event, so the current context (the default
             # parent) belongs to an unrelated span. Start from an empty
-            # Context so every tool call is its own root span.
+            # Context, or from the caller's span when the request carried a
+            # `traceparent`. The event does not keep the caller's trace flags,
+            # so the remote parent is marked sampled and the host's sampler
+            # decides.
+            parent = Context()
+            if event.trace_id and event.parent_span_id:
+                parent = set_span_in_context(
+                    NonRecordingSpan(
+                        SpanContext(
+                            trace_id=int(event.trace_id, 16),
+                            span_id=int(event.parent_span_id, 16),
+                            is_remote=True,
+                            trace_flags=TraceFlags(TraceFlags.SAMPLED),
+                        )
+                    ),
+                    parent,
+                )
             span = self._tracer.start_span(
                 f"tools/call {event.tool_name}",
-                context=Context(),
+                context=parent,
                 kind=SpanKind.SERVER,
                 attributes=attributes,
                 start_time=start_ns,

{mcpsignals-2.3.2 → mcpsignals-2.5.0}/src/mcpsignals/sinks/postgres.py

@@ -26,6 +26,14 @@ _TOOL_CALL_COLUMNS = [
     "arguments",
     "intent",
     "transport",
+    "protocol_version",
+    "request_id",
+    "trace_id",
+    "parent_span_id",
+    "result_type",
+    "error_code",
+    "read_only_hint",
+    "destructive_hint",
 ]
 
 
@@ -80,6 +88,14 @@ class PostgresSink:
                         _json.dumps(e.arguments) if e.arguments is not None else None,
                         e.intent,
                         e.transport,
+                        e.protocol_version,
+                        e.request_id,
+                        e.trace_id,
+                        e.parent_span_id,
+                        e.result_type,
+                        e.error_code,
+                        e.read_only_hint,
+                        e.destructive_hint,
                     )
                     for e in tool_calls
                 ]