@omercnet/paseo-omp 0.3.0 → 0.4.0-next.114.1

package/server/provider/connection.ts

@@ -9,6 +9,10 @@ import {
   requireProviderCapabilities,
 } from "@getpaseo/plugin/server/provider";
 import type { OmpBrowserAuthorizationRegistry } from "../mcp-browser";
+import type {
+  OmpOperationalFailure,
+  OmpOperationalFailureReporter,
+} from "../operational-failure-diagnostics";
 import { discoverOmpCatalog } from "./catalog";
 import { normalizeOmpCatalogOptions } from "./config-normalization";
 import type { OmpMcpConnector } from "./host-tools";
@@ -58,6 +62,7 @@ const MAX_CONNECTION_SESSIONS = 32;
 const MAX_ACTIVE_OPERATIONS = 128;
 const MAX_PROVIDER_INPUT_BYTES = 2 * 1024 * 1024;
 const MAX_NESTED_OPTION_BYTES = 256 * 1024;
+const MAX_ENV_ENTRIES = 256;
 const MAX_NATIVE_SESSION_RESERVATIONS = 256;
 
 function hasOwnEntries(value: unknown): boolean {
@@ -68,6 +73,19 @@ function hasOwnEntries(value: unknown): boolean {
   return false;
 }
 
+function providerOptionsExceedPreflightLimits(value: unknown): boolean {
+  if (
+    boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES, MAX_ENV_ENTRIES) === Number.POSITIVE_INFINITY
+  ) {
+    return true;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const unrelatedOptions = Object.fromEntries(
+    Object.entries(value).filter(([key]) => key !== "env" && key !== "inheritEnv"),
+  );
+  return boundedJsonBytes(unrelatedOptions, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY;
+}
+
 function preflightProviderInput(input: unknown): void {
   if (!input || typeof input !== "object") throw new OmpPublicError("Invalid provider request");
   const record = input as Record<string, unknown>;
@@ -82,7 +100,16 @@ function preflightProviderInput(input: unknown): void {
       throw new OmpPublicError("Session persistence input is too large");
     }
     const config = record.config as Record<string, unknown> | undefined;
-    for (const value of [config?.mcpServers, config?.providerOptions, config?.settings]) {
+    if (
+      (config?.env !== undefined &&
+        boundedJsonBytes(config.env, MAX_NESTED_OPTION_BYTES, MAX_ENV_ENTRIES) ===
+          Number.POSITIVE_INFINITY) ||
+      (config?.providerOptions !== undefined &&
+        providerOptionsExceedPreflightLimits(config.providerOptions))
+    ) {
+      throw new OmpPublicError("Session configuration is too large");
+    }
+    for (const value of [config?.mcpServers, config?.settings]) {
       if (
         value !== undefined &&
         boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
@@ -109,13 +136,17 @@ function preflightProviderInput(input: unknown): void {
     }
   }
   if (record.type === "catalog" || record.type === "sessions") {
-    for (const value of [record.providerOptions, record.settings]) {
-      if (
-        value !== undefined &&
-        boundedJsonBytes(value, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
-      ) {
-        throw new OmpPublicError("Provider configuration is too large");
-      }
+    if (
+      record.providerOptions !== undefined &&
+      providerOptionsExceedPreflightLimits(record.providerOptions)
+    ) {
+      throw new OmpPublicError("Provider configuration is too large");
+    }
+    if (
+      record.settings !== undefined &&
+      boundedJsonBytes(record.settings, MAX_NESTED_OPTION_BYTES) === Number.POSITIVE_INFINITY
+    ) {
+      throw new OmpPublicError("Provider configuration is too large");
     }
   }
   if (record.type === "session.prompt") {
@@ -656,6 +687,7 @@ export function createOmpConnection(
   browserAuthorizationRegistry?: OmpBrowserAuthorizationRegistry,
   reportDiagnostic: (diagnostic: OmpConnectionDiagnostic) => void = (diagnostic) =>
     console.error("OMP provider failure", diagnostic),
+  reportOperationalFailure: OmpOperationalFailureReporter = () => {},
 ): ProviderConnection {
   const errorDetails = (error: unknown, fallback: string): { message: string } => {
     if (isOmpPublicError(error)) return { message: error.message };
@@ -669,6 +701,13 @@ export function createOmpConnection(
     }
     return { message: `${fallback} (diagnostic ${diagnosticId})` };
   };
+  const recordOperationalFailure = (failure: OmpOperationalFailure) => {
+    try {
+      reportOperationalFailure(failure);
+    } catch {
+      // Diagnostics must never affect provider requests or cleanup.
+    }
+  };
   const safeCapabilities = [...new Set(capabilities)].filter(
     (capability) =>
       SUPPORTED_CAPABILITIES[capability] &&
@@ -775,6 +814,9 @@ export function createOmpConnection(
                 },
           });
         } catch (error) {
+          if (!closing) {
+            recordOperationalFailure({ category: "session-open", stage: "catalog" });
+          }
           if (isOmpCleanupFailure(error)) catalogCleanup = error.cleanup;
           if (!closing) requestFailure(input.requestId, error, "OMP catalog discovery failed");
         }
@@ -898,6 +940,7 @@ export function createOmpConnection(
             environment,
             mcpConnector,
             mcpInitializationTimeoutMs,
+            reportOperationalFailure,
           );
           const discoveredNativeSessionId = session.persistenceSessionId;
           if (discoveredNativeSessionId) nativeSessionId = discoveredNativeSessionId;
@@ -950,6 +993,15 @@ export function createOmpConnection(
             nativeReservations.release(nativeSessionId, token);
           }
         } catch (error) {
+          const openingCancelled =
+            closing || controller.signal.aborted || opening.get(input.sessionId)?.token !== token;
+          if (!openingCancelled) {
+            recordOperationalFailure(
+              input.history === "replay" || nativeSessionId
+                ? { category: "replay-recovery", stage: "persisted-replay" }
+                : { category: "session-open", stage: "startup" },
+            );
+          }
           deleteSession(input.sessionId, token);
           let cleanupError: unknown;
           if (session) {

package/server/provider/host-tools.ts

@@ -3,6 +3,11 @@ import type {
   ProviderMcpServerConfig,
   ProviderSessionConfig,
 } from "@getpaseo/plugin/server/provider";
+import type {
+  OmpOperationalFailure,
+  OmpOperationalFailureReporter,
+} from "../operational-failure-diagnostics";
+import { isValidImagePayload } from "./image";
 import {
   type ConnectedMcpClient,
   type ConnectedMcpTool,
@@ -25,6 +30,11 @@ import {
   utf8Bytes,
 } from "./security";
 
+type HostToolFailureStage = Extract<
+  OmpOperationalFailure,
+  { category: "tool-projector"; stage: `host-tool-${string}` }
+>["stage"];
+
 const INTERNAL_PASEO_MCP_PATH = "/mcp/agents";
 const RESERVED_PASEO_NAMESPACE = "paseo";
 const MAX_MCP_SERVERS = 32;
@@ -37,7 +47,13 @@ const MAX_HOST_TOOL_DESCRIPTION_BYTES = 64 * 1024;
 const MAX_HOST_TOOL_SCHEMA_BYTES = 256 * 1024;
 const MAX_HOST_TOOL_CATALOG_BYTES = 768 * 1024;
 const MAX_HOST_TOOL_RESULT_BYTES = 12 * 1024 * 1024;
+const MAX_HOST_TOOL_CONTENT_BLOCKS = 512;
+const MAX_HOST_TOOL_TEXT_BYTES = 1024 * 1024;
+const MAX_HOST_TOOL_IMAGE_DATA_BYTES = 8 * 1024 * 1024;
 const MAX_STRUCTURED_CONTENT_FALLBACK_BYTES = 1024 * 1024;
+const CONTENT_TRUNCATED_NOTICE = "[MCP result content truncated: exceeded size limits]";
+const DETAILS_OMITTED_NOTICE = "[MCP structured content omitted: exceeded size limits]";
+const RESULT_TRUNCATED_NOTICE = "[MCP content truncated; details omitted]";
 const MAX_PENDING_HOST_TOOL_CALLS = 64;
 const MAX_PENDING_HOST_TOOL_BYTES = 8 * 1024 * 1024;
 const DEFAULT_INITIALIZATION_TIMEOUT_MS = 20_000;
@@ -72,6 +88,7 @@ export interface OmpHostToolsOpenOptions {
   initializationTimeoutMs?: number;
   callTimeoutMs?: number;
   callScheduler?: OmpHostToolScheduler;
+  reportOperationalFailure?: OmpOperationalFailureReporter;
 }
 
 type ClassifiedServer = {
@@ -272,42 +289,171 @@ async function discoverMcpTools(
   throw new OmpPublicError("MCP server tool-list pagination exceeds the supported limit");
 }
 
-function normalizeResult(result: unknown): OmpHostToolResult["result"] {
-  if (
-    !result ||
-    typeof result !== "object" ||
+type HostToolContentBlock = OmpHostToolResult["result"]["content"][number];
+
+function hostToolContentIsBounded(content: readonly HostToolContentBlock[]): boolean {
+  return (
     boundedJsonBytes(
-      result,
+      content,
+      MAX_HOST_TOOL_RESULT_BYTES,
+      MAX_HOST_TOOL_CONTENT_BLOCKS,
+      MAX_HOST_TOOL_IMAGE_DATA_BYTES,
+      4_096,
+    ) !== Number.POSITIVE_INFINITY
+  );
+}
+
+function noticeBlock(text: string): HostToolContentBlock {
+  return { type: "text", text };
+}
+
+function appendBoundedNotice(
+  content: readonly HostToolContentBlock[],
+  notice: string,
+): HostToolContentBlock[] {
+  const trailingNotice = content.at(-1)?.text;
+  const contentWasTruncated =
+    trailingNotice === CONTENT_TRUNCATED_NOTICE || trailingNotice === RESULT_TRUNCATED_NOTICE;
+  const prefix = (contentWasTruncated ? content.slice(0, -1) : content).slice(
+    0,
+    MAX_HOST_TOOL_CONTENT_BLOCKS - 1,
+  );
+  const markerText =
+    notice === DETAILS_OMITTED_NOTICE && contentWasTruncated ? RESULT_TRUNCATED_NOTICE : notice;
+  const marker = noticeBlock(markerText);
+  while (prefix.length > 0 && !hostToolContentIsBounded([...prefix, marker])) prefix.pop();
+  return [...prefix, marker];
+}
+
+function boundedTextPrefix(
+  prefix: readonly HostToolContentBlock[],
+  block: HostToolContentBlock,
+): HostToolContentBlock | undefined {
+  if (block.type !== "text" || typeof block.text !== "string") return;
+  const marker = noticeBlock(CONTENT_TRUNCATED_NOTICE);
+  let low = 0;
+  let high = block.text.length;
+  let best = "";
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    let text = block.text.slice(0, middle);
+    if (/\p{Surrogate}$/u.test(text)) text = text.slice(0, -1);
+    const candidate = { type: "text", text } satisfies HostToolContentBlock;
+    if (hostToolContentIsBounded([...prefix, candidate, marker])) {
+      best = text;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return best ? { type: "text", text: best } : undefined;
+}
+
+function normalizeContent(content: readonly unknown[]): HostToolContentBlock[] {
+  const normalized: HostToolContentBlock[] = [];
+  for (const value of content) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      throw new Error("MCP tool returned invalid content");
+    }
+    const block = value as Record<string, unknown>;
+    if (typeof block.type !== "string" || !block.type || utf8Bytes(block.type) > 256) {
+      throw new Error("MCP tool returned invalid content");
+    }
+
+    let candidate: HostToolContentBlock;
+    let blockWasTruncated = false;
+    if (block.type === "text") {
+      if (typeof block.text !== "string") throw new Error("MCP tool returned invalid text content");
+      const text = truncateUtf8(block.text, MAX_HOST_TOOL_TEXT_BYTES);
+      candidate = { ...block, type: "text", text } as HostToolContentBlock;
+      blockWasTruncated = text !== block.text;
+    } else if (block.type === "image") {
+      if (typeof block.data !== "string" || typeof block.mimeType !== "string") {
+        throw new Error("MCP tool returned invalid image content");
+      }
+      if (block.data.length > MAX_HOST_TOOL_IMAGE_DATA_BYTES) {
+        return appendBoundedNotice(normalized, CONTENT_TRUNCATED_NOTICE);
+      }
+      if (!isValidImagePayload(block.data, block.mimeType, MAX_HOST_TOOL_IMAGE_DATA_BYTES)) {
+        throw new Error("MCP tool returned invalid image content");
+      }
+      candidate = {
+        ...block,
+        type: "image",
+        data: block.data,
+        mimeType: block.mimeType,
+      } as HostToolContentBlock;
+    } else {
+      candidate = block as HostToolContentBlock;
+    }
+
+    if (normalized.length >= MAX_HOST_TOOL_CONTENT_BLOCKS) {
+      return appendBoundedNotice(normalized, CONTENT_TRUNCATED_NOTICE);
+    }
+    if (!hostToolContentIsBounded([...normalized, candidate])) {
+      const prefix = boundedTextPrefix(normalized, candidate);
+      return appendBoundedNotice(
+        prefix ? [...normalized, prefix] : normalized,
+        CONTENT_TRUNCATED_NOTICE,
+      );
+    }
+    normalized.push(candidate);
+    if (blockWasTruncated) return appendBoundedNotice(normalized, CONTENT_TRUNCATED_NOTICE);
+  }
+  return normalized;
+}
+
+function structuredContentIsBounded(value: unknown): boolean {
+  return (
+    boundedJsonBytes(
+      value,
       MAX_HOST_TOOL_RESULT_BYTES,
       1_024,
       MAX_HOST_TOOL_RESULT_BYTES,
       4_096,
-    ) === Number.POSITIVE_INFINITY
-  ) {
-    throw new Error("MCP tool returned an invalid or oversized result");
+    ) !== Number.POSITIVE_INFINITY
+  );
+}
+
+function normalizeResult(result: unknown): OmpHostToolResult["result"] {
+  if (!result || typeof result !== "object" || Array.isArray(result)) {
+    throw new Error("MCP tool returned an invalid result");
   }
   const record = result as Record<string, unknown>;
   if (Array.isArray(record.content)) {
     const details = record.structuredContent;
-    const content =
-      record.content.length === 0 && details !== undefined
-        ? [
-            {
-              type: "text",
-              text: truncateUtf8(JSON.stringify(details), MAX_STRUCTURED_CONTENT_FALLBACK_BYTES),
-            },
-          ]
-        : record.content;
-    return parseOmpHostToolAgentResult({
+    const detailsAreBounded = details === undefined || structuredContentIsBounded(details);
+    let content = normalizeContent(record.content);
+    if (content.length === 0 && details !== undefined && detailsAreBounded) {
+      content = [
+        {
+          type: "text",
+          text: truncateUtf8(JSON.stringify(details), MAX_STRUCTURED_CONTENT_FALLBACK_BYTES),
+        },
+      ];
+    }
+    if (!detailsAreBounded) content = appendBoundedNotice(content, DETAILS_OMITTED_NOTICE);
+
+    let normalized = parseOmpHostToolAgentResult({
       content,
-      ...(details !== undefined ? { details } : {}),
+      ...(details !== undefined && detailsAreBounded ? { details } : {}),
       ...(typeof record.isError === "boolean" ? { isError: record.isError } : {}),
     });
+    if (!structuredContentIsBounded(normalized)) {
+      normalized = parseOmpHostToolAgentResult({
+        content: appendBoundedNotice(content, DETAILS_OMITTED_NOTICE),
+        ...(typeof record.isError === "boolean" ? { isError: record.isError } : {}),
+      });
+    }
+    return normalized;
   }
   if (Object.hasOwn(record, "toolResult")) {
+    const details = record.toolResult;
+    const detailsAreBounded = structuredContentIsBounded(details);
     return parseOmpHostToolAgentResult({
-      content: [{ type: "text", text: "MCP tool completed" }],
-      details: record.toolResult,
+      content: [noticeBlock(detailsAreBounded ? "MCP tool completed" : DETAILS_OMITTED_NOTICE)],
+      ...(detailsAreBounded ? { details } : {}),
+      ...(typeof record.isError === "boolean" ? { isError: record.isError } : {}),
     });
   }
   throw new Error("MCP tool returned an unsupported result");
@@ -360,6 +506,7 @@ export class OmpHostToolsBridge {
     private readonly targets: ReadonlyMap<string, ToolTarget>,
     private readonly callTimeoutMs: number,
     private readonly callScheduler: OmpHostToolScheduler,
+    private readonly reportOperationalFailure: OmpOperationalFailureReporter,
   ) {
     this.labels = new Map(definitions.map(({ name, label }) => [name, label ?? name]));
   }
@@ -476,6 +623,7 @@ export class OmpHostToolsBridge {
         targets,
         callTimeoutMs,
         callScheduler,
+        options.reportOperationalFailure ?? (() => {}),
       );
     } catch (error) {
       const cleanupTasks = [
@@ -604,7 +752,11 @@ export class OmpHostToolsBridge {
     if (!runtime) return true;
     const target = this.targets.get(event.toolName);
     if (!target) {
-      this.sendTerminal(runtime, errorResult(event.id, "Unknown OMP host tool"));
+      this.sendOperationalError(
+        "host-tool-unknown",
+        runtime,
+        errorResult(event.id, "Unknown OMP host tool"),
+      );
       return true;
     }
     const retainedBytes = boundedJsonBytes(
@@ -620,7 +772,11 @@ export class OmpHostToolsBridge {
       retainedBytes === Number.POSITIVE_INFINITY ||
       this.pendingBytes + retainedBytes > MAX_PENDING_HOST_TOOL_BYTES
     ) {
-      this.sendTerminal(runtime, errorResult(event.id, "OMP host tool bridge is at capacity"));
+      this.sendOperationalError(
+        "host-tool-capacity",
+        runtime,
+        errorResult(event.id, "OMP host tool bridge is at capacity"),
+      );
       return true;
     }
     const pending: PendingCall = {
@@ -658,23 +814,30 @@ export class OmpHostToolsBridge {
       })
       .then((result) => {
         if (!this.isCurrent(event.id, pending)) return;
-        let terminal: OmpHostToolResult;
         try {
           const normalized = normalizeResult(result);
-          terminal = {
+          const terminal: OmpHostToolResult = {
             type: "host_tool_result",
             id: event.id,
             result: normalized,
             ...(normalized.isError !== undefined ? { isError: normalized.isError } : {}),
           };
+          if (normalized.isError) {
+            this.sendOperationalError("host-tool-call", runtime, terminal, pending);
+          } else this.sendTerminal(runtime, terminal, pending);
         } catch {
-          terminal = errorResult(event.id, "MCP host tool execution failed");
+          this.sendOperationalError(
+            "host-tool-normalization",
+            runtime,
+            errorResult(event.id, "MCP host tool execution failed"),
+            pending,
+          );
         }
-        this.sendTerminal(runtime, terminal, pending);
       })
       .catch(() => {
         if (!this.isCurrent(event.id, pending)) return;
-        this.sendTerminal(
+        this.sendOperationalError(
+          "host-tool-call",
           runtime,
           errorResult(event.id, "MCP host tool execution failed"),
           pending,
@@ -704,30 +867,113 @@ export class OmpHostToolsBridge {
     result: OmpHostToolResult,
   ): OmpHostToolResult {
     const limit = runtime.maxHostToolFrameBytes ?? 1024 * 1024;
+    const fits = (candidate: OmpHostToolResult) => {
+      try {
+        return Buffer.byteLength(`${JSON.stringify(candidate)}\n`) <= limit;
+      } catch {
+        return false;
+      }
+    };
+    if (fits(result)) return result;
+
+    const withoutDetails: OmpHostToolResult = {
+      ...result,
+      result: {
+        content: appendBoundedNotice(result.result.content, DETAILS_OMITTED_NOTICE),
+        ...(result.result.isError !== undefined ? { isError: result.result.isError } : {}),
+      },
+    };
+    if (result.result.details !== undefined && fits(withoutDetails)) return withoutDetails;
+
+    const trailingNotice = result.result.content.at(-1)?.text;
+    const detailsWereOmitted =
+      trailingNotice === DETAILS_OMITTED_NOTICE || trailingNotice === RESULT_TRUNCATED_NOTICE;
+    const contentWasTruncated =
+      trailingNotice === CONTENT_TRUNCATED_NOTICE || trailingNotice === RESULT_TRUNCATED_NOTICE;
+    const marker = noticeBlock(
+      result.result.details !== undefined || detailsWereOmitted
+        ? RESULT_TRUNCATED_NOTICE
+        : CONTENT_TRUNCATED_NOTICE,
+    );
+    const sourceContent =
+      detailsWereOmitted || contentWasTruncated
+        ? result.result.content.slice(0, -1)
+        : result.result.content;
+    const boundedContent: HostToolContentBlock[] = [];
+    const terminalWith = (content: HostToolContentBlock[]): OmpHostToolResult => ({
+      ...result,
+      result: {
+        content,
+        ...(result.result.isError !== undefined ? { isError: result.result.isError } : {}),
+      },
+    });
+    for (const block of sourceContent) {
+      const candidate = terminalWith([...boundedContent, block, marker]);
+      if (fits(candidate)) {
+        boundedContent.push(block);
+        continue;
+      }
+      if (block.type === "text" && typeof block.text === "string") {
+        let low = 0;
+        let high = block.text.length;
+        let best = "";
+        while (low <= high) {
+          const middle = Math.floor((low + high) / 2);
+          let text = block.text.slice(0, middle);
+          if (/\p{Surrogate}$/u.test(text)) text = text.slice(0, -1);
+          if (fits(terminalWith([...boundedContent, { type: "text", text }, marker]))) {
+            best = text;
+            low = middle + 1;
+          } else {
+            high = middle - 1;
+          }
+        }
+        if (best) boundedContent.push({ type: "text", text: best });
+      }
+      break;
+    }
+    const bounded = terminalWith([...boundedContent, marker]);
+    return fits(bounded) ? bounded : errorResult(result.id, OMP_HOST_TOOL_FRAME_LIMIT_ERROR);
+  }
+
+  private recordOperationalFailure(failure: OmpOperationalFailure): void {
     try {
-      if (Buffer.byteLength(`${JSON.stringify(result)}\n`) <= limit) return result;
+      this.reportOperationalFailure(failure);
     } catch {
-      // Fall through to the bounded error result.
+      // Diagnostics must never affect host tool execution or result delivery.
     }
-    return errorResult(result.id, OMP_HOST_TOOL_FRAME_LIMIT_ERROR);
   }
 
-  private sendTerminal(
+  private sendOperationalError(
+    stage: HostToolFailureStage,
     runtime: OmpRuntimeSession,
     result: OmpHostToolResult,
     pending?: PendingCall,
   ): void {
+    if (this.sendTerminal(runtime, result, pending)) {
+      this.recordOperationalFailure({ category: "tool-projector", stage });
+    }
+  }
+
+  private sendTerminal(
+    runtime: OmpRuntimeSession,
+    result: OmpHostToolResult,
+    pending?: PendingCall,
+  ): boolean {
     const bounded = this.boundedTerminal(runtime, result);
-    if (pending && !this.isCurrent(bounded.id, pending)) return;
+    if (pending && !this.isCurrent(bounded.id, pending)) return false;
     try {
       runtime.sendHostToolResult(bounded);
+      return true;
     } catch (error) {
       this.failRuntime(runtime, error);
+      return false;
     }
   }
 
   private failRuntime(runtime: OmpRuntimeSession, error: unknown): void {
     if (this.runtime !== runtime) return;
+    this.recordOperationalFailure({ category: "tool-projector", stage: "host-tool-delivery" });
     const failure =
       error instanceof Error ? error : new Error("OMP host tool result delivery failed");
     this.detach();
@@ -748,7 +994,11 @@ export class OmpHostToolsBridge {
     if (!this.isCurrent(id, pending)) return;
     this.releasePending(id, pending);
     pending.controller.abort(new Error("OMP MCP host tool call timed out"));
-    this.sendTerminal(pending.runtime, errorResult(id, "OMP MCP host tool call timed out"));
+    this.sendOperationalError(
+      "host-tool-timeout",
+      pending.runtime,
+      errorResult(id, "OMP MCP host tool call timed out"),
+    );
   }
 
   private releasePending(id: string, pending: PendingCall): void {

package/server/provider/mcp-transport.ts

@@ -224,6 +224,7 @@ export class SupervisedStdioClientTransport implements Transport {
       this.notifyClose();
       return;
     }
+    const treeCleanup = this.startTreeCleanup();
     if (!this.exited) {
       try {
         child.stdin.end();
@@ -231,7 +232,7 @@ export class SupervisedStdioClientTransport implements Transport {
         // Process-tree cleanup remains authoritative when stdin is already closed.
       }
     }
-    const terminated = await this.startTreeCleanup();
+    const terminated = await treeCleanup;
     const exited =
       this.spawnFailedWithoutProcess ||
       this.exited ||