A tracing adapter can pass its internal tests while capturing nothing in an installed application.
The imports resolve. The tool executes. No exception tells the developer that the trace is incomplete. A test that only checks the tool's return value misses the failure entirely.
I maintain AgentInspect. A public external evaluation of the older 6.29.1 release examined this boundary with the MCP SDK. It documented capture/runtime-identity and wrapper-compatibility problems. That repository is a historical reproduction, not a verdict on today's release.
For this article, I built a separate installed-package smoke test against agent-inspect@6.31.35, @agent-inspect/mcp@6.31.35, and MCP SDK 1.31.0. The question was narrower than “does the library work?”: does the published integration observe the calls made by a real SDK consumer?
Package topology can change runtime behavior
Imagine that a root package creates an asynchronous run context while an adapter consults another bundled copy of the context module. The application has an active run in one instance; the adapter sees none in the other.
A dependency tree can look deduplicated while the build output still contains duplicated runtime state. Listing installed versions is useful, but it does not prove that both imports share the same live context.
Another boundary is object behavior. SDK clients can expose prototype methods, getters, and methods that depend on the original receiver. A wrapper that merely spreads an instance into a new object may lose functionality. A proxy that forwards a method with the wrong receiver can also break private state access.
These are integration properties. Test them at the consumer boundary.
The server's execution counter is independent of the tracing adapter.
Use the real SDK without requiring a remote service
The companion examples install exact versions through a committed lockfile. They create a real MCP Client and Server connected with InMemoryTransport.createLinkedPair().
The transport is in-memory; the SDK classes are not mocks. The server exposes one synthetic echo tool and increments a counter whenever its tool handler runs.
The central consumer assertions are:
const wrapped = wrapMcpClient(client, { serverName: "fixture" }); assert.ok(wrapped instanceof Client); await wrapped.ping(); await inspectRun("sdk-capture", async () => { await wrapped.listTools(); const result = await wrapped.callTool({ name: "echo", arguments: {}, }); assert.equal(result.content[0].text, "fixture-ok"); }, { traceDir, silent: true }); This is an excerpt; sdk-smoke-shared.cjs contains the server setup, trace readback, and finally cleanup. The complete harness then asserts:
assert.equal(calls, 1); assert.equal(starts.length, 2); assert.ok(starts.some(row => row.name === "mcp:tools/list")); assert.ok(starts.some(row => row.name === "mcp:echo")); Two captured steps are expected because the fixture lists tools and calls one tool. The independent handler count confirms one actual tool execution.
Without that comparison, “the trace contains one span” could pass while another executed call disappeared.
Exercise both module systems explicitly
The test launches two separate consumers: one using ESM imports and another using CommonJS require. Each uses the public package entry points.
On the Linux environment used for the original article test, Node 24.22.1, both passed:
| Consumer | Server tool calls | Captured list/call steps | SDK ping |
|---|---|---|---|
| ESM | 1 | 2 | Pass |
| CommonJS | 1 | 2 | Pass |
During final editorial verification, I installed the same lockfile and reran the complete nine-test harness on macOS arm64 with Node 22.22.3. The ESM and CommonJS SDK consumers passed there as well, with the same one-call/two-captured-step result. That adds a second bounded environment; it does not turn two passing environments into a universal compatibility claim.
The test also checks the original result and closes the wrapped client and server. It does not establish that every SDK method, transport, authentication path, or operating system is compatible. Native Windows, HTTP and stdio transports, OAuth, reconnect behavior, and the full SDK surface remain outside this fixture.
That last sentence is part of the result, not a disclaimer to hide below it.
Use Docker to bound the reproduction
The examples include a small Dockerfile:
FROM node:24-bookworm-slim WORKDIR /work COPY package.json package-lock.json ./ RUN npm ci --ignore-scripts --no-audit --no-fund COPY *.mjs *.cjs ./ CMD ["npm", "test"] Build while dependency downloads are available, then run the synthetic suite without external networking:
docker build -t agent-evidence-probes ./examples docker run --rm --network none agent-evidence-probes Docker's none network driver leaves only loopback networking. That is useful here because the SDK transport is in-memory and the tests need no provider credentials. A blocked network makes accidental external dependencies easier to detect.
The Node tests were executed for this article; the Docker commands were reviewed but not executed because this environment had no Docker engine. Before publishing a container-specific result, run them yourself. For repeatable CI, record an approved immutable image digest; a major-version tag can move.
Make the release matrix reflect real support claims
Linux-in-Docker is not a substitute for native operating-system testing. The added macOS rerun improves the matrix, but it does not cover native Windows. Nor do two passing Node environments validate every version in a peer-dependency range.
Add cells based on the support policy: module system, operating system, Node version, SDK version, and relevant transport. Keep unsupported or untested cells visible rather than coloring an entire platform green from one smoke test.
A published contributor report can extend the evidence, but label its exact environment and release. Don’t silently combine different versions into one universal compatibility claim.
Let external reproductions improve the test boundary
The useful lesson from a third-party integration report is often not just the bug. It is the missing test shape: public imports, real SDK objects, independently counted calls, and persisted evidence inspected after execution.
Keep that shape in the release process. A clean monorepo suite is valuable, but the user installs a package, not your test workspace.
Implementation references
- Repository's packed MCP SDK evidence script
- MCP client wrapper
- Companion:
examples/sdk-smoke.mjs,sdk-smoke.cjs,sdk-smoke-shared.cjs, andDockerfile.

