@@ -307,9 +307,9 @@ separate APIs for creating each kind:
 [`session.createUnidirectionalStream()`][]. Streams initiated by a remote
 peer are delivered via the [`session.onstream`][] callback. When the
 negotiated application protocol supports the stream-level callbacks (e.g.
-HTTP/3) and any of them are configured, incoming streams can instead be
-consumed entirely through those callbacks (such as `onheaders`) and
-registering `onstream` is optional.
+HTTP/3) and an `onheaders` callback is configured, incoming streams can
+instead be consumed entirely through it and registering `onstream` is
+optional.
 
 There are two ways to write data to a stream:
 
@@ -414,8 +414,8 @@ A typical client session progresses through these stages:
 On the server side, call [`quic.listen()`][] with a callback. The callback
 fires for each incoming session after the TLS handshake begins. Incoming
 streams arrive via the [`session.onstream`][] callback, or, for HTTP/3
-sessions with stream-level callbacks configured, directly through those
-callbacks (see the [minimal HTTP/3 server][] example).
+sessions with an `onheaders` callback configured, directly through that
+callback (see the [minimal HTTP/3 server][] example).
 
 [`session.destroy()`][] is available for immediate teardown — all open streams
 are destroyed and the session is closed without waiting for them to finish.
@@ -1117,11 +1117,13 @@ added: v23.8.0
 The callback to invoke when a new stream is initiated by a remote peer. Read/write.
 
 If no `onstream` callback is set and the stream has no other consumer, an
-incoming stream is destroyed on arrival and a warning is emitted. Stream-level
-callbacks (such as `onheaders`) count as a consumer when the negotiated
-application protocol supports them (e.g. HTTP/3), so an HTTP/3 server that
-handles requests entirely through those callbacks does not need to set
-`onstream`.
+incoming stream is destroyed on arrival and a warning is emitted. An
+`onheaders` callback counts as a consumer when the negotiated application
+protocol supports it (e.g. HTTP/3), because it is invoked for every incoming
+request stream. Other stream-level callbacks (`ontrailers`, `oninfo`,
+`onwanttrailers`) do not, since they are conditional or outbound-only and
+would leave the stream unobservable. An HTTP/3 server that handles requests
+entirely through `onheaders` does not need to set `onstream`.
 
 ### `session.ondatagram`
 
@@ -4023,7 +4025,7 @@ const encoder = new TextEncoder();
 const endpoint = await listen((session) => {
   // The session.onstream callback fires for each new client-initiated
   // stream. It is optional here: with `onheaders` configured below,
-  // request streams are consumed through the stream-level callbacks.
+  // request streams are consumed through that callback.
 }, {
   sni: { '*': { keys: [defaultKey], certs: [defaultCert] } },
   // ALPN defaults to 'h3'.
 
@@ -4138,7 +4138,12 @@ class QuicSession {
    */
   #hasStreamConsumer() {
     if (typeof this.#inner.onstream === 'function') return true;
-    if (this[kStreamCallbacks] == null) return false;
+    // Only onheaders is guaranteed to fire for every incoming stream when
+    // the negotiated application supports stream callbacks (e.g. HTTP/3).
+    // Other stream callbacks are conditional (ontrailers, oninfo) or
+    // outbound-only (onwanttrailers) and do not expose the stream, so they
+    // do not count as a consumer.
+    if (typeof this[kStreamCallbacks]?.onheaders !== 'function') return false;
     return getQuicSessionState(this).streamCallbacksSupported === 1;
   }
 
 
@@ -11,7 +11,7 @@
 // streams (and emits a warning), so unconsumed streams cannot
 // accumulate and hold flow control credit.
 
-import { hasQuic, skip, mustCall } from '../common/index.mjs';
+import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
@@ -129,3 +129,45 @@ function failOnConsumerWarning(warning) {
   await clientSession.close();
   await serverEndpoint.close();
 }
+
+// --- Stream callbacks that do not expose the stream are not a consumer ---
+// Only `onheaders` is invoked for every incoming h3 request stream.
+// `ontrailers` and `oninfo` are conditional and `onwanttrailers` is
+// outbound-only, so a session registering only those callbacks has no way
+// to observe an incoming stream and it must be destroyed with the warning.
+for (const callbackName of ['ontrailers', 'oninfo', 'onwanttrailers']) {
+  const warned = Promise.withResolvers();
+  process.on('warning', function onWarning(warning) {
+    if (warning.message === kWarning) {
+      process.off('warning', onWarning);
+      warned.resolve();
+    }
+  });
+
+  const serverEndpoint = await listen(mustCall((serverSession) => {
+    serverSession.onerror = () => {};
+  }), {
+    sni: { '*': { keys: [key], certs: [cert] } },
+    [callbackName]: mustNotCall(),
+  });
+
+  const clientSession = await connect(serverEndpoint.address, {
+    servername: 'localhost',
+    verifyPeer: 'manual',
+  });
+  await clientSession.opened;
+
+  const stream = await clientSession.createBidirectionalStream({
+    headers: {
+      ':method': 'GET',
+      ':path': '/test',
+      ':scheme': 'https',
+      ':authority': 'localhost',
+    },
+  });
+  stream.onerror = () => {};
+
+  await warned.promise;
+  await clientSession.close();
+  await serverEndpoint.close();
+}