mcpsignals 2.2.0__tar.gz → 2.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpsignals
-Version: 2.2.0
+Version: 2.3.2
 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
@@ -82,6 +82,64 @@ Off by default: no tool arguments are recorded unless you opt in with
 value types** are recorded, never values. See the root README's redaction
 section before enabling this in anything handling real user data.
 
+## Identity: `user_id` and `org_id`
+
+`resolve_identity` is the only thing that ever fills in `user_id` and
+`org_id`. Without it both stay `None` on every event.
+
+```python
+def resolve_identity(ctx):
+    account = look_up_account(ctx)  # your auth layer, not ours
+    return (account.id, account.org_id) if account else (None, None)
+
+
+instrument(server, server_name="my-server", resolve_identity=resolve_identity)
+```
+
+It receives the middleware's `ServerRequestContext` and returns a
+`(user_id, org_id)` tuple. It may be a plain function or a coroutine;
+either is awaited correctly. Returning `(None, None)` records a null
+identity, which is what the column means for an anonymous call.
+
+The Node.js package differs here: it passes `{ sessionId }` rather than the
+raw context, and returns an object. Porting a resolver between the two means
+rewriting both ends. Note that the context Python hands you carries no
+session id of its own, for the reason in the limitation below.
+
+It runs **after** your handler settles, so a slow resolver never lands in
+`duration_ms` (wall time from call start to response, per
+[`schema/events.md`](../../schema/events.md)). A resolver that raises is
+logged once and costs you the identity on that event, nothing else: the
+event is still recorded, and your handler's result or exception reaches the
+client untouched.
+
+## Buffering and flush timing
+
+Events are batched in memory rather than written one per call.
+`buffer_size` (default 20) flushes after that many events;
+`flush_interval_s` (default 5.0) flushes on a timer. Whichever comes first
+wins, plus a best-effort `atexit` flush.
+
+```python
+instrument(
+    server,
+    server_name="my-server",
+    sinks=[PostgresSink()],
+    buffer_size=100,  # fewer, larger writes
+    flush_interval_s=10.0,
+)
+```
+
+Raising `buffer_size` trades memory and worst-case loss for fewer round
+trips: a crash loses whatever is still buffered.
+
+The `atexit` flush is best-effort only. It needs an event loop that may not
+exist at interpreter shutdown, and it logs a warning and drops the buffer
+when there is none. Anything that must not be lost should go through an
+explicit `await handle_for(server).flush()` before you shut down.
+
+`flush_interval_s=None` is manual mode, covered next.
+
 ## Request-scoped runtimes and manual flushing
 
 `instrument()` returns the server unchanged. `handle_for(server)` returns an

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

@@ -56,6 +56,64 @@ Off by default: no tool arguments are recorded unless you opt in with
 value types** are recorded, never values. See the root README's redaction
 section before enabling this in anything handling real user data.
 
+## Identity: `user_id` and `org_id`
+
+`resolve_identity` is the only thing that ever fills in `user_id` and
+`org_id`. Without it both stay `None` on every event.
+
+```python
+def resolve_identity(ctx):
+    account = look_up_account(ctx)  # your auth layer, not ours
+    return (account.id, account.org_id) if account else (None, None)
+
+
+instrument(server, server_name="my-server", resolve_identity=resolve_identity)
+```
+
+It receives the middleware's `ServerRequestContext` and returns a
+`(user_id, org_id)` tuple. It may be a plain function or a coroutine;
+either is awaited correctly. Returning `(None, None)` records a null
+identity, which is what the column means for an anonymous call.
+
+The Node.js package differs here: it passes `{ sessionId }` rather than the
+raw context, and returns an object. Porting a resolver between the two means
+rewriting both ends. Note that the context Python hands you carries no
+session id of its own, for the reason in the limitation below.
+
+It runs **after** your handler settles, so a slow resolver never lands in
+`duration_ms` (wall time from call start to response, per
+[`schema/events.md`](../../schema/events.md)). A resolver that raises is
+logged once and costs you the identity on that event, nothing else: the
+event is still recorded, and your handler's result or exception reaches the
+client untouched.
+
+## Buffering and flush timing
+
+Events are batched in memory rather than written one per call.
+`buffer_size` (default 20) flushes after that many events;
+`flush_interval_s` (default 5.0) flushes on a timer. Whichever comes first
+wins, plus a best-effort `atexit` flush.
+
+```python
+instrument(
+    server,
+    server_name="my-server",
+    sinks=[PostgresSink()],
+    buffer_size=100,  # fewer, larger writes
+    flush_interval_s=10.0,
+)
+```
+
+Raising `buffer_size` trades memory and worst-case loss for fewer round
+trips: a crash loses whatever is still buffered.
+
+The `atexit` flush is best-effort only. It needs an event loop that may not
+exist at interpreter shutdown, and it logs a warning and drops the buffer
+when there is none. Anything that must not be lost should go through an
+explicit `await handle_for(server).flush()` before you shut down.
+
+`flush_interval_s=None` is manual mode, covered next.
+
 ## Request-scoped runtimes and manual flushing
 
 `instrument()` returns the server unchanged. `handle_for(server)` returns an

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/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.2.0"
+version = "2.3.2"
 description = "Drop-in instrumentation for MCP servers. Writes tool-call events to a database you own."
 readme = "README.md"
 license = "MIT"
@@ -41,7 +41,7 @@ Issues = "https://github.com/zentered-studios/mcpsignals/issues"
 dev = [
     "pytest>=8.3",
     "pytest-asyncio>=0.24", # required by asyncio_mode = "auto" below
-    "ruff>=0.15,<0.16",     # single source of truth for the version CI uses
+    "ruff>=0.15,<0.17",     # single source of truth for the version CI uses
 ]
 
 [tool.hatch.build.targets.wheel]

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

@@ -1,4 +1,4 @@
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import ToolCallEvent
 from mcpsignals.handle import InstrumentHandle, handle_for
 from mcpsignals.instrument import instrument
 from mcpsignals.redaction import RedactionConfig
@@ -9,5 +9,4 @@ __all__ = [
     "InstrumentHandle",
     "RedactionConfig",
     "ToolCallEvent",
-    "SessionSummaryEvent",
 ]

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/buffer.py

@@ -12,13 +12,11 @@ import atexit
 import logging
 from collections.abc import Sequence
 
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import Event
 from mcpsignals.sinks.base import Sink
 
 logger = logging.getLogger("mcpsignals")
 
-Event = ToolCallEvent | SessionSummaryEvent
-
 
 class EventBuffer:
     def __init__(

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

@@ -29,16 +29,7 @@ class ToolCallEvent:
     transport: str | None = None
 
 
-@dataclass
-class SessionSummaryEvent:
-    event_type: Literal["session_summary"] = field(init=False, default="session_summary")
-    ts: datetime = field(default=None)  # type: ignore[assignment]
-    session_id: str = ""
-    server_name: str = ""
-    server_version: str | None = None
-    user_id: str | None = None
-    org_id: str | None = None
-    call_count: int = 0
-    distinct_tools_used: int = 0
-    wall_duration_ms: int = 0
-    error_count: int = 0
+#: What a sink receives. There is one event type today, so this is an alias
+#: for `ToolCallEvent` rather than a union - it stays as the name sinks are
+#: written against, and as the seam a second event type would widen.
+Event = ToolCallEvent

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

@@ -18,10 +18,22 @@ 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.
+
+Guarantee: nothing the library does around a tool call can change what the
+client receives. The real handler always runs, its result is returned
+unchanged, and its exception propagates unchanged. Every library-side step
+(request byte counting, `resolve_identity`, redaction, event construction,
+`buffer.add`) is guarded: a failure is logged once per `instrument()` call on
+the `mcpsignals` logger, then suppressed, and the step falls back to a
+neutral value (`request_bytes` 0, identity `(None, None)`, `arguments`
+None). A failing redactor therefore records `arguments=None`, never the raw
+arguments. A sink failure is handled separately by EventBuffer, also logged
+once per sink.
 """
 
 import inspect
 import json
+import logging
 import time
 from collections.abc import Awaitable, Callable, Mapping, Sequence
 from dataclasses import replace
@@ -33,11 +45,19 @@ from mcpsignals.error_kind import classify_error
 from mcpsignals.events import ToolCallEvent
 from mcpsignals.handle import InstrumentHandle
 from mcpsignals.handle import register as _register_handle
-from mcpsignals.intent_capture import enabled_for, inject_schema, strip_injected
+from mcpsignals.intent_capture import (
+    MAX_IDENTIFIER_LENGTH,
+    bounded,
+    enabled_for,
+    inject_schema,
+    strip_injected,
+)
 from mcpsignals.redaction import RedactionConfig, redact_arguments
 from mcpsignals.sinks.base import Sink
 from mcpsignals.sinks.console import ConsoleSink
 
+logger = logging.getLogger("mcpsignals")
+
 ResolveIdentity = Callable[
     [Any], tuple[str | None, str | None] | Awaitable[tuple[str | None, str | None]]
 ]
@@ -106,6 +126,23 @@ def instrument(
     buffer = EventBuffer(active_sinks, buffer_size=buffer_size, flush_interval_s=flush_interval_s)
     _register_handle(server, InstrumentHandle(buffer))
 
+    # Same "log once, then suppress" pattern EventBuffer uses per sink, scoped
+    # to this instrument() call: one line is enough to surface a broken
+    # resolver or redactor, and a line per tool call would drown the host's logs.
+    warned = False
+
+    def _warn_once(step: str, exc: BaseException) -> None:
+        nonlocal warned
+        if warned:
+            return
+        warned = True
+        logger.error(
+            "mcpsignals: %s failed; the tool result is unaffected and further telemetry "
+            "errors from this instrument() call are suppressed: %r",
+            step,
+            exc,
+        )
+
     async def _mcpsignals_middleware(ctx, call_next):
         if ctx.method == "tools/list":
             result = await call_next(ctx)
@@ -131,13 +168,34 @@ def instrument(
         if ctx.method != "tools/call":
             return await call_next(ctx)
 
+        # `ts` is when the call started, not when it finished, and
+        # `duration_ms` is wall time from call start to response
+        # (schema/events.md): both are anchored here, before any library-side
+        # step, and `_record` reads them back after the handler settles.
+        #
+        # Not datetime.UTC: that alias is 3.11+, and requires-python allows
+        # 3.10. Ruff's UP017 would rewrite this, which is why ruff.toml pins
+        # target-version to py310.
+        ts = datetime.now(timezone.utc)
+        start = time.perf_counter()
+
         params = ctx.params or {}
-        tool_name = params.get("name", "")
+        # `name` comes straight off the `tools/call` request, not from the
+        # registration: a client can send any string here (the call then
+        # fails, but the failed event still records it), so it takes the same
+        # identifier cap as the intent fields. The uncapped value still drives
+        # the intent-capture lookup and the forwarded call below.
+        raw_tool_name = params.get("name", "")
+        tool_name = bounded(raw_tool_name, MAX_IDENTIFIER_LENGTH) or ""
         raw_arguments = params.get("arguments") or {}
-        request_bytes = len(json.dumps(raw_arguments, default=str).encode())
+        try:
+            request_bytes = len(json.dumps(raw_arguments, default=str).encode())
+        except Exception as exc:  # noqa: BLE001 - an unmeasurable request never blocks the handler
+            _warn_once("request byte count", exc)
+            request_bytes = 0
 
         tool_intent_enabled = enabled_for(
-            tool_name, global_enabled=intent_capture, overrides=intent_capture_tools
+            raw_tool_name, global_enabled=intent_capture, overrides=intent_capture_tools
         )
         if tool_intent_enabled:
             clean_arguments, extracted = strip_injected(raw_arguments)
@@ -149,36 +207,41 @@ def instrument(
             extracted = {"session_id": None, "agent_id": None, "intent": None}
             forward_ctx = ctx
 
-        user_id: str | None = None
-        org_id: str | None = None
-        if resolve_identity is not None:
-            identity = resolve_identity(ctx)
-            if inspect.isawaitable(identity):
-                identity = await identity
-            if identity:
-                user_id, org_id = identity
-
+        # The client declares its own name/version in the `initialize`
+        # handshake, so both are caller-controlled and take the same
+        # identifier cap as the intent fields.
         client_name: str | None = None
         client_version: str | None = None
         client_params = getattr(ctx.session, "client_params", None)
         client_info = getattr(client_params, "client_info", None) if client_params else None
         if client_info is not None:
-            client_name = client_info.name
-            client_version = client_info.version
+            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"
 
-        start = time.perf_counter()
-        error: BaseException | None = None
-        result = None
-        try:
-            result = await call_next(forward_ctx)
-            return result
-        except BaseException as exc:
-            error = exc
-            raise
-        finally:
+        async def _record(ts: datetime, error: BaseException | None, result: Any) -> None:
+            # First thing: the handler has just settled, so this is the
+            # response time. Everything below, `resolve_identity` included,
+            # is outside the timed window.
             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.
+            user_id: str | None = None
+            org_id: str | None = None
+            if resolve_identity is not None:
+                try:
+                    identity = resolve_identity(ctx)
+                    if inspect.isawaitable(identity):
+                        identity = await identity
+                    if identity:
+                        user_id, org_id = identity
+                except Exception as exc:  # noqa: BLE001 - a broken resolver never blocks the handler
+                    _warn_once("resolve_identity", exc)
+                    user_id, org_id = None, None
+
             if error is not None:
                 success = False
                 error_message: str | None = str(error)[:2000]
@@ -190,13 +253,33 @@ def instrument(
                     error_message = error_message[:2000]
                 response_bytes = len(_serialize_for_bytes(result))
 
-            arguments = redact_arguments(clean_arguments, redaction) if capture_arguments else None
+            # Guarded on its own so a broken redactor still leaves an event
+            # behind, recorded with `arguments=None` rather than the raw args.
+            #
+            # The `json.dumps` is not a formatting step, it is a proof that the
+            # value survives encoding. Every sink re-serializes `arguments` on
+            # its way out (`json.dumps` in postgres and bigquery,
+            # `dataclasses.asdict` then `json.dumps` in the console sink), and a
+            # value that cannot be encoded makes that whole `write()` raise.
+            # EventBuffer catches it, so the server is never affected, but the
+            # entire batch goes with it - including the unrelated events flushed
+            # alongside. Proving it here costs one event's `arguments` instead of
+            # a whole flush. Deliberately strict (no `default=`): it has to match
+            # the least forgiving sink, not the most.
+            #
+            # Only a `redaction.redactor` or a `redaction.allow` entry can
+            # produce such a value; the default type-only markers always encode.
+            arguments = None
+            if capture_arguments:
+                try:
+                    arguments = redact_arguments(clean_arguments, redaction)
+                    json.dumps(arguments)
+                except Exception as exc:  # noqa: BLE001 - never fall back to the raw arguments
+                    _warn_once("redaction", exc)
+                    arguments = None
 
             event = ToolCallEvent(
-                # Not datetime.UTC: that alias is 3.11+, and requires-python
-                # allows 3.10. Ruff's UP017 would rewrite this, which is why
-                # ruff.toml pins target-version to py310.
-                ts=datetime.now(timezone.utc),
+                ts=ts,
                 server_name=server_name,
                 server_version=server_version,
                 tool_name=tool_name,
@@ -218,5 +301,23 @@ def instrument(
             )
             await buffer.add(event)
 
+        error: BaseException | None = None
+        result = None
+        try:
+            result = await call_next(forward_ctx)
+            return result
+        except BaseException as exc:
+            error = exc
+            raise
+        finally:
+            # An exception raised inside `finally` replaces the handler's
+            # return value or exception, so the whole recording step is
+            # guarded here. `Exception` only: a cancellation raised while
+            # awaiting the resolver or the buffer must still propagate.
+            try:
+                await _record(ts, error, result)
+            except Exception as exc:  # noqa: BLE001 - telemetry must never change the tool result
+                _warn_once("event recording", exc)
+
     server.middleware.append(_mcpsignals_middleware)
     return server

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/intent_capture.py

@@ -13,17 +13,20 @@ from typing import Any
 
 INJECTED_KEYS = ("session_id", "agent_id", "intent")
 
-# Length caps on the three values the calling agent supplies. Without them
-# these are the only unbounded caller-controlled strings on an event, and a
-# sink that batches writes in a transaction (Cloudflare D1's `batch()`, for
-# one) loses every unrelated event in the flush when one oversized value fails
-# its statement. Capping here rather than in each sink means every sink,
-# including third-party and future ones, inherits the bound.
+# Length caps on the caller-controlled strings that land on an event: the
+# three intent-capture values the calling agent supplies here, plus
+# `tool_name` (read off the `tools/call` request) and `client_name`/
+# `client_version` (declared in the `initialize` handshake), which
+# `instrument.py` bounds with the same `bounded()`. Without them a sink that
+# batches writes in a transaction (Cloudflare D1's `batch()`, for one) loses
+# every unrelated event in the flush when one oversized value fails its
+# statement. Capping before the event is built rather than in each sink means
+# every sink, including third-party and future ones, inherits the bound.
 #
-# `intent` is prose and takes the same 2000 as `error_message`.
-# `session_id`/`agent_id` are identifiers - a UUID is 36 chars - so they take a
-# much tighter cap. Oversized values are truncated rather than dropped: losing
-# the tail of an id is cheaper than losing the event.
+# `intent` is prose and takes the same 2000 as `error_message`. The rest are
+# identifiers - a UUID is 36 chars - so they take a much tighter cap. Oversized
+# values are truncated rather than dropped: losing the tail of an id is cheaper
+# than losing the event.
 MAX_INTENT_LENGTH = 2000
 MAX_IDENTIFIER_LENGTH = 128
 
@@ -69,10 +72,14 @@ def inject_schema(input_schema: dict[str, Any] | None) -> dict[str, Any]:
     return schema
 
 
-def _bounded(value: Any, max_length: int) -> str | None:
-    # A caller can send any JSON type for these keys. Anything that isn't a
-    # string can't be length-bounded, so it's dropped rather than forwarded
-    # into an event field typed `str | None`.
+def bounded(value: Any, max_length: int) -> str | None:
+    """Return `value` cut to `max_length` characters, or None for a non-string.
+
+    A caller can send any JSON type for these keys. Anything that isn't a
+    string can't be length-bounded, so it's dropped rather than forwarded
+    into an event field typed `str | None`. Python slices by code point, so
+    the cut never lands inside a character.
+    """
     if not isinstance(value, str):
         return None
     return value[:max_length]
@@ -88,5 +95,5 @@ def strip_injected(
     the library.
     """
     args = dict(arguments) if arguments else {}
-    extracted = {key: _bounded(args.pop(key, None), _MAX_LENGTHS[key]) for key in INJECTED_KEYS}
+    extracted = {key: bounded(args.pop(key, None), _MAX_LENGTHS[key]) for key in INJECTED_KEYS}
     return args, extracted

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/redaction.py

@@ -11,10 +11,18 @@ from typing import Any
 
 
 def _type_marker(value: Any) -> dict[str, str]:
+    # JSON type names, shared with the Node.js package (see redaction.ts) so a
+    # query on `__type` works the same over either package's events.
     if isinstance(value, bool):
-        type_name = "bool"
+        type_name = "boolean"
+    elif isinstance(value, (int, float)):
+        type_name = "number"
+    elif isinstance(value, str):
+        type_name = "string"
     elif isinstance(value, list):
         type_name = "array"
+    elif isinstance(value, dict):
+        type_name = "object"
     elif value is None:
         type_name = "null"
     else:

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/sinks/base.py

@@ -1,6 +1,6 @@
 from typing import Protocol, runtime_checkable
 
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import ToolCallEvent
 
 
 @runtime_checkable
@@ -10,4 +10,4 @@ class Sink(Protocol):
     what EventBuffer already does upstream.
     """
 
-    async def write(self, events: list[ToolCallEvent | SessionSummaryEvent]) -> None: ...
+    async def write(self, events: list[ToolCallEvent]) -> None: ...

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/sinks/bigquery.py

@@ -14,7 +14,7 @@ import asyncio
 import dataclasses
 import json
 
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import ToolCallEvent
 
 
 class BigQuerySink:
@@ -34,10 +34,7 @@ class BigQuerySink:
         row = dataclasses.asdict(event)
         row.pop("event_type", None)
         row["ts"] = event.ts.isoformat() if event.ts else None
-        if isinstance(event, ToolCallEvent):
-            row["arguments"] = (
-                json.dumps(row["arguments"]) if row["arguments"] is not None else None
-            )
+        row["arguments"] = json.dumps(row["arguments"]) if row["arguments"] is not None else None
         return row
 
     def _insert_sync(self, table: str, rows: list[dict]) -> None:
@@ -47,11 +44,8 @@ class BigQuerySink:
         if errors:
             raise RuntimeError(f"bigquery insert errors for {table_ref}: {errors}")
 
-    async def write(self, events: list[ToolCallEvent | SessionSummaryEvent]) -> None:
+    async def write(self, events: list[ToolCallEvent]) -> None:
         tool_calls = [self._row(e) for e in events if isinstance(e, ToolCallEvent)]
-        summaries = [self._row(e) for e in events if isinstance(e, SessionSummaryEvent)]
 
         if tool_calls:
             await asyncio.to_thread(self._insert_sync, "tool_call", tool_calls)
-        if summaries:
-            await asyncio.to_thread(self._insert_sync, "session_summary", summaries)

{mcpsignals-2.2.0 → mcpsignals-2.3.2}/src/mcpsignals/sinks/console.py

@@ -3,7 +3,7 @@ import json
 import sys
 from typing import TextIO
 
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import ToolCallEvent
 
 
 class ConsoleSink:
@@ -20,7 +20,7 @@ class ConsoleSink:
     def __init__(self, stream: TextIO | None = None) -> None:
         self._stream = stream
 
-    async def write(self, events: list[ToolCallEvent | SessionSummaryEvent]) -> None:
+    async def write(self, events: list[ToolCallEvent]) -> None:
         stream = self._stream if self._stream is not None else sys.stdout
         for event in events:
             payload = dataclasses.asdict(event)

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

@@ -14,7 +14,7 @@ Where our schema has no equivalent convention, we use a custom
 
 import json
 
-from mcpsignals.events import SessionSummaryEvent, ToolCallEvent
+from mcpsignals.events import ToolCallEvent
 
 
 class OtlpSink:
@@ -25,14 +25,11 @@ class OtlpSink:
             tracer = trace.get_tracer("mcpsignals")
         self._tracer = tracer
 
-    async def write(self, events: list[ToolCallEvent | SessionSummaryEvent]) -> None:
+    async def write(self, events: list[ToolCallEvent]) -> None:
         from opentelemetry.context import Context
         from opentelemetry.trace import SpanKind, Status, StatusCode
 
         for event in events:
-            if not isinstance(event, ToolCallEvent):
-                continue  # session_summary has no OTel span mapping; warehouse sinks carry it
-
             attributes = {
                 "gen_ai.operation.name": "execute_tool",
                 "gen_ai.tool.name": event.tool_name,