fix: address Copilot review round 1 on #2318

- fetchTracking: count NDJSON streams line by line instead of leaving
  them at zero forever; justify the detached watcher promise; document
  that a partial SSE block at end-of-stream is dropped, as the SDK's own
  parser (no flush) and the SSE spec drop it.
- uncapturedBodyNote: case-insensitive content-type lookup, and a
  stream label (SSE / NDJSON) for the Network badge.
- InspectorClient: `openedAt` is when the response headers arrived, not
  when the GET went out; the snapshot copies its request records; a
  request the transport failed to send is rolled back out of the
  unanswered set via a new `trackSendFailure` callback; a raw-wire
  timeout is built as the SDK's own timeout shape and annotated the
  same way, so callers see one kind of timeout.
- Remote session storage revives the nested `stream.closedAt` Date.
- Hook test models a legacy double with `Object.defineProperty`, not a
  double cast.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01APKSYHGxXBUpnR7ErFiLJn
Signed-off-by: cliffhall <cliff@futurescale.com>

core/mcp/inspectorClient.ts

@@ -270,6 +270,7 @@ import {
   findHeader,
   isLongLivedStreamResponse,
 } from "./fetchTracking.js";
+import { SdkError, SdkErrorCode } from "@modelcontextprotocol/client";
 import {
   annotateRequestTimeout,
   type ConnectionDiagnostics,
@@ -1130,6 +1131,15 @@ export class InspectorClient extends InspectorClientEventTarget {
         };
         this.dispatchTypedEvent("message", entry);
       },
+      trackSendFailure: (message: JSONRPCRequest) => {
+        // The frame never reached the wire, so it is not awaiting a response.
+        // Leaving it would report a request the server never saw as
+        // unanswered, in every timeout message and Connection Info row, until
+        // the session resets (#2318).
+        if (this.outstandingRequests.delete(message.id)) {
+          this.dispatchConnectionDiagnosticsChange();
+        }
+      },
       trackResponse: (
         message: JSONRPCResultResponse | JSONRPCErrorResponse,
         origin: MessageOrigin,
@@ -2915,8 +2925,19 @@ export class InspectorClient extends InspectorClientEventTarget {
     const raw = await new Promise<unknown>((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pendingRawWireRequests.delete(id);
+        // The same error, with the same annotation, as an SDK request that
+        // times out: this path bypasses `Protocol.request`, so it builds the
+        // SDK's own timeout shape and runs it through the decorator's
+        // annotation by hand — a raw-wire caller sees one kind of timeout,
+        // not two (#2318).
         reject(
-          new Error(`Raw request "${method}" timed out after ${timeoutMs} ms`),
+          annotateRequestTimeout(
+            new SdkError(SdkErrorCode.RequestTimeout, "Request timed out", {
+              timeout: timeoutMs,
+            }),
+            method,
+            this.getConnectionDiagnostics(),
+          ),
         );
       }, timeoutMs);
       this.pendingRawWireRequests.set(id, { resolve, reject, timer });
@@ -6083,7 +6104,9 @@ export class InspectorClient extends InspectorClientEventTarget {
     this.notificationStream = {
       id: entry.id,
       url: entry.url,
-      openedAt: entry.timestamp.getTime(),
+      // The entry's `timestamp` is when the request went out; the stream is
+      // open from when the response headers arrived, `duration` later.
+      openedAt: entry.timestamp.getTime() + (entry.duration ?? 0),
       eventCount: 0,
     };
     this.dispatchConnectionDiagnosticsChange();
@@ -6098,7 +6121,12 @@ export class InspectorClient extends InspectorClientEventTarget {
   getConnectionDiagnostics(): ConnectionDiagnostics {
     return {
       capturedAt: Date.now(),
-      outstandingRequests: [...this.outstandingRequests.values()],
+      // Copies, not the tracked records: the snapshot is handed to callers
+      // and carried on errors, and a mutation there must not reach the
+      // correlation state.
+      outstandingRequests: [...this.outstandingRequests.values()].map(
+        (request) => ({ ...request }),
+      ),
       ...(this.lastResponse && { lastResponse: { ...this.lastResponse } }),
       ...(this.notificationStream && {
         notificationStream: this.publicStreamState(this.notificationStream),