Function runMCPToolWithDeadline

src/node/services/mcpServerManager.ts:74–126

(
  start: () => Promise<T>,
  opts: { toolName: string; timeoutMs: number; signal?: AbortSignal }
)

 * so abort cannot leave orphaned timers or dangling promises.
 */
export async function runMCPToolWithDeadline<T>(
  start: () => Promise<T>,
  opts: { toolName: string; timeoutMs: number; signal?: AbortSignal }
): Promise<T> {
  const { signal, timeoutMs, toolName } = opts;

  // Pre-abort short-circuit: skip all async work if already canceled.
  if (signal?.aborted) {
    throw new MCPDeadlineError("Interrupted");
  }

  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
  let cleanupAbort: (() => void) | undefined;

  // Lazy start: tool execution begins only after pre-abort check passes.
  const op = Promise.resolve().then(start);

  const timeout = new Promise<never>((_resolve, reject) => {
    timeoutHandle = setTimeout(
      () => reject(new MCPDeadlineError(`MCP tool '${toolName}' timed out after ${timeoutMs}ms`)),
      timeoutMs
    );
    if (
      timeoutHandle !== undefined &&
      typeof timeoutHandle === "object" &&
      "unref" in timeoutHandle &&
      typeof timeoutHandle.unref === "function"
    ) {
      timeoutHandle.unref();
    }
  });

  const aborted = signal
    ? new Promise<never>((_resolve, reject) => {
        const onAbort = () => reject(new MCPDeadlineError("Interrupted"));
        signal.addEventListener("abort", onAbort, { once: true });
        cleanupAbort = () => signal.removeEventListener("abort", onAbort);
      })
    : undefined;

  try {
    const racers: Array<Promise<T>> = [op, timeout];
    if (aborted) {
      racers.push(aborted);
    }
    return await Promise.race(racers);
  } finally {
    if (timeoutHandle) {
      clearTimeout(timeoutHandle);
    }
    cleanupAbort?.();
  }
}

function shouldRecycleClientAfterToolError(error: unknown): boolean {
  return isClosedClientError(error) || error instanceof MCPDeadlineError;