@trpc/server 11.0.0-rc.637 → 11.0.0-rc.642

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.d.ts

@@ -3,7 +3,6 @@
  */
 export declare function withMaxDuration<T>(iterable: AsyncIterable<T>, opts: {
     maxDurationMs: number;
-    abortCtrl: AbortController;
 }): AsyncGenerator<T>;
 /**
  * Derives a new {@link AsyncGenerator} based of {@link iterable}, that yields its first
@@ -13,6 +12,5 @@ export declare function withMaxDuration<T>(iterable: AsyncIterable<T>, opts: {
 export declare function takeWithGrace<T>(iterable: AsyncIterable<T>, opts: {
     count: number;
     gracePeriodMs: number;
-    abortCtrl: AbortController;
 }): AsyncGenerator<T>;
 //# sourceMappingURL=asyncIterable.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,eAAe,CAAA;CAAE,GAC1D,cAAc,CAAC,CAAC,CAAC,CA8BnB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,eAAe,CAAC;CAC5B,GACA,cAAc,CAAC,CAAC,CAAC,CAoCnB"}
+{"version":3,"file":"asyncIterable.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/asyncIterable.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACtC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9B,cAAc,CAAC,CAAC,CAAC,CA8BnB;AAED;;;;GAIG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,GACA,cAAc,CAAC,CAAC,CAAC,CAkCnB"}

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.js

@@ -1,13 +1,13 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
-var disposablePromiseTimer = require('./disposablePromiseTimer.js');
+var timerResource = require('./timerResource.js');
 
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */ async function* withMaxDuration(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const timer = disposablePromiseTimer.disposablePromiseTimer(opts.maxDurationMs);
+    const timer = timerResource.timerResource(opts.maxDurationMs);
     try {
         const timerPromise = timer.start();
         // declaration outside the loop for garbage collection reasons
@@ -17,9 +17,8 @@ var disposablePromiseTimer = require('./disposablePromiseTimer.js');
                 iterator.next(),
                 timerPromise
             ]);
-            if (result === disposablePromiseTimer.disposablePromiseTimerResult) {
+            if (result === timerResource.disposablePromiseTimerResult) {
                 // cancelled due to timeout
-                opts.abortCtrl.abort();
                 const res = await iterator.return?.();
                 return res?.value;
             }
@@ -44,7 +43,7 @@ var disposablePromiseTimer = require('./disposablePromiseTimer.js');
     const iterator = iterable[Symbol.asyncIterator]();
     // declaration outside the loop for garbage collection reasons
     let result;
-    const timer = disposablePromiseTimer.disposablePromiseTimer(opts.gracePeriodMs);
+    const timer = timerResource.timerResource(opts.gracePeriodMs);
     try {
         let count = opts.count;
         let timerPromise = new Promise(()=>{
@@ -55,7 +54,7 @@ var disposablePromiseTimer = require('./disposablePromiseTimer.js');
                 iterator.next(),
                 timerPromise
             ]);
-            if (result === disposablePromiseTimer.disposablePromiseTimerResult) {
+            if (result === timerResource.disposablePromiseTimerResult) {
                 // cancelled
                 const res = await iterator.return?.();
                 return res?.value;
@@ -66,8 +65,6 @@ var disposablePromiseTimer = require('./disposablePromiseTimer.js');
             yield result.value;
             if (--count === 0) {
                 timerPromise = timer.start();
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                timerPromise.then(()=>opts.abortCtrl.abort());
             }
             // free up reference for garbage collection
             result = null;

package/dist/unstable-core-do-not-import/stream/utils/asyncIterable.mjs

@@ -1,11 +1,11 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposablePromiseTimer.mjs';
+import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs';
 
 /**
  * Derives a new {@link AsyncGenerator} based on {@link iterable}, that automatically stops after the specified duration.
  */ async function* withMaxDuration(iterable, opts) {
     const iterator = iterable[Symbol.asyncIterator]();
-    const timer = disposablePromiseTimer(opts.maxDurationMs);
+    const timer = timerResource(opts.maxDurationMs);
     try {
         const timerPromise = timer.start();
         // declaration outside the loop for garbage collection reasons
@@ -17,7 +17,6 @@ import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposab
             ]);
             if (result === disposablePromiseTimerResult) {
                 // cancelled due to timeout
-                opts.abortCtrl.abort();
                 const res = await iterator.return?.();
                 return res?.value;
             }
@@ -42,7 +41,7 @@ import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposab
     const iterator = iterable[Symbol.asyncIterator]();
     // declaration outside the loop for garbage collection reasons
     let result;
-    const timer = disposablePromiseTimer(opts.gracePeriodMs);
+    const timer = timerResource(opts.gracePeriodMs);
     try {
         let count = opts.count;
         let timerPromise = new Promise(()=>{
@@ -64,8 +63,6 @@ import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposab
             yield result.value;
             if (--count === 0) {
                 timerPromise = timer.start();
-                // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                timerPromise.then(()=>opts.abortCtrl.abort());
             }
             // free up reference for garbage collection
             result = null;

package/dist/unstable-core-do-not-import/stream/utils/{disposablePromiseTimer.d.ts → timerResource.d.ts}

@@ -1,6 +1,6 @@
 export declare const disposablePromiseTimerResult: unique symbol;
-export declare function disposablePromiseTimer(ms: number): {
+export declare function timerResource(ms: number): {
     start(): Promise<typeof disposablePromiseTimerResult>;
     [Symbol.dispose]: () => void;
 };
-//# sourceMappingURL=disposablePromiseTimer.d.ts.map
+//# sourceMappingURL=timerResource.d.ts.map

package/dist/unstable-core-do-not-import/stream/utils/timerResource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timerResource.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/timerResource.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,4BAA4B,eAAW,CAAC;AACrD,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM;;;EAsBvC"}

package/dist/unstable-core-do-not-import/stream/utils/{disposablePromiseTimer.js → timerResource.js}

@@ -4,7 +4,7 @@
 var _Symbol;
 (_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
 const disposablePromiseTimerResult = Symbol();
-function disposablePromiseTimer(ms) {
+function timerResource(ms) {
     let timer = null;
     return {
         start () {
@@ -24,5 +24,5 @@ function disposablePromiseTimer(ms) {
     };
 }
 
-exports.disposablePromiseTimer = disposablePromiseTimer;
 exports.disposablePromiseTimerResult = disposablePromiseTimerResult;
+exports.timerResource = timerResource;

package/dist/unstable-core-do-not-import/stream/utils/{disposablePromiseTimer.mjs → timerResource.mjs}

@@ -2,7 +2,7 @@
 var _Symbol;
 (_Symbol = Symbol).dispose ?? (_Symbol.dispose = Symbol());
 const disposablePromiseTimerResult = Symbol();
-function disposablePromiseTimer(ms) {
+function timerResource(ms) {
     let timer = null;
     return {
         start () {
@@ -22,4 +22,4 @@ function disposablePromiseTimer(ms) {
     };
 }
 
-export { disposablePromiseTimer, disposablePromiseTimerResult };
+export { disposablePromiseTimerResult, timerResource };

package/dist/unstable-core-do-not-import/stream/utils/withPing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAuB,QAAQ,CAAC,MAAM,EACpC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,MAAM,GACrB,cAAc,CAAC,MAAM,GAAG,OAAO,QAAQ,CAAC,CAmC1C"}
+{"version":3,"file":"withPing.d.ts","sourceRoot":"","sources":["../../../../src/unstable-core-do-not-import/stream/utils/withPing.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,eAAiB,CAAC;AAEvC;;;GAGG;AACH,wBAAuB,QAAQ,CAAC,MAAM,EACpC,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,EAC/B,cAAc,EAAE,MAAM,GACrB,cAAc,CAAC,MAAM,GAAG,OAAO,QAAQ,CAAC,CAmC1C"}

package/dist/unstable-core-do-not-import/stream/utils/withPing.js

@@ -1,7 +1,7 @@
 'use strict';
 
 var unpromise = require('../../../vendor/unpromise/unpromise.js');
-var disposablePromiseTimer = require('./disposablePromiseTimer.js');
+var timerResource = require('./timerResource.js');
 
 const PING_SYM = Symbol('ping');
 /**
@@ -13,13 +13,13 @@ const PING_SYM = Symbol('ping');
     let result;
     let nextPromise = iterator.next();
     while(true){
-        const pingPromise = disposablePromiseTimer.disposablePromiseTimer(pingIntervalMs);
+        const pingPromise = timerResource.timerResource(pingIntervalMs);
         try {
             result = await unpromise.Unpromise.race([
                 nextPromise,
                 pingPromise.start()
             ]);
-            if (result === disposablePromiseTimer.disposablePromiseTimerResult) {
+            if (result === timerResource.disposablePromiseTimerResult) {
                 // cancelled
                 yield PING_SYM;
                 continue;

package/dist/unstable-core-do-not-import/stream/utils/withPing.mjs

@@ -1,5 +1,5 @@
 import { Unpromise } from '../../../vendor/unpromise/unpromise.mjs';
-import { disposablePromiseTimerResult, disposablePromiseTimer } from './disposablePromiseTimer.mjs';
+import { disposablePromiseTimerResult, timerResource } from './timerResource.mjs';
 
 const PING_SYM = Symbol('ping');
 /**
@@ -11,7 +11,7 @@ const PING_SYM = Symbol('ping');
     let result;
     let nextPromise = iterator.next();
     while(true){
-        const pingPromise = disposablePromiseTimer(pingIntervalMs);
+        const pingPromise = timerResource(pingIntervalMs);
         try {
             result = await Unpromise.race([
                 nextPromise,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trpc/server",
-  "version": "11.0.0-rc.637+19da060cb",
+  "version": "11.0.0-rc.642+5c904587e",
   "description": "The tRPC server library",
   "author": "KATT",
   "license": "MIT",
@@ -110,7 +110,8 @@
     "rpc",
     "shared",
     "unstable-core-do-not-import",
-    "!**/*.test.*"
+    "!**/*.test.*",
+    "!**/__tests__"
   ],
   "publishConfig": {
     "access": "public"
@@ -156,5 +157,8 @@
     "next": "*",
     "ws": "*"
   },
-  "gitHead": "19da060cb0e05c75682ec813c606b51c6c52ee19"
+  "peerDependencies": {
+    "typescript": ">=5.6.2"
+  },
+  "gitHead": "5c904587e6f3e3eaadb1bbd80d6aa38d20c00800"
 }

package/src/unstable-core-do-not-import/http/resolveResponse.ts

@@ -466,7 +466,6 @@ export async function resolveResponse<TRouter extends AnyRouter>(
           const stream = sseStreamProducer({
             ...config.sse,
             data: iterable,
-            abortCtrl: result?.abortCtrl ?? new AbortController(),
             serialize: (v) => config.transformer.output.serialize(v),
             formatError(errorOpts) {
               const error = getTRPCErrorFromUnknown(errorOpts.error);

package/src/unstable-core-do-not-import/rootConfig.ts

@@ -82,7 +82,7 @@ export interface RootConfig<TTypes extends RootTypes> {
     enabled?: boolean;
   } & Pick<
     SSEStreamProducerOptions,
-    'ping' | 'emitAndEndImmediately' | 'maxDurationMs'
+    'ping' | 'emitAndEndImmediately' | 'maxDurationMs' | 'client'
   >;
   experimental?: {};
 }

package/src/unstable-core-do-not-import/stream/jsonl.ts

@@ -425,13 +425,20 @@ export async function jsonlStreamConsumer<THead>(opts: {
 
   type ControllerChunk = ChunkData | StreamInterruptedError;
   type ChunkController = ReadableStreamDefaultController<ControllerChunk>;
+  /**
+   * This is needed as new values can come in before the controller has read the chunk
+   * Not pretty, could likely be refactored and omitted somehow
+   */
+  const chunkDeferred = new Map<ChunkIndex, Deferred<ChunkController>>();
 
-  const controllers = withRefCount(
-    new Map<ChunkIndex, ChunkController>(),
-    () => {
+  const controllers = new Map<ChunkIndex, ChunkController>();
+
+  const maybeAbort = () => {
+    if (chunkDeferred.size === 0 && controllers.size === 0) {
+      // nothing is listening to the stream anymore
       opts.abortController?.abort();
-    },
-  );
+    }
+  };
 
   function decodeChunkDefinition(value: ChunkDefinition) {
     const [_path, type, chunkId] = value;
@@ -440,6 +447,13 @@ export async function jsonlStreamConsumer<THead>(opts: {
 
     controllers.set(chunkId, stream.controller);
 
+    // resolve chunk deferred if it exists
+    const deferred = chunkDeferred.get(chunkId);
+    if (deferred) {
+      deferred.resolve(stream.controller);
+      chunkDeferred.delete(chunkId);
+    }
+
     switch (type) {
       case CHUNK_VALUE_TYPE_PROMISE: {
         return new Promise((resolve, reject) => {
@@ -473,60 +487,66 @@ export async function jsonlStreamConsumer<THead>(opts: {
             .catch(reject)
             .finally(() => {
               controllers.delete(chunkId);
+              maybeAbort();
             });
         });
       }
       case CHUNK_VALUE_TYPE_ASYNC_ITERABLE: {
-        return {
-          [Symbol.asyncIterator]: () => {
-            const reader = stream.readable.getReader();
-            const iterator: AsyncIterator<unknown> = {
-              next: async () => {
-                const { done, value } = await reader.read();
-                if (value instanceof StreamInterruptedError) {
-                  throw value;
-                }
-                if (done) {
-                  controllers.delete(chunkId);
-                  return {
-                    done: true,
-                    value: undefined,
-                  };
-                }
-
-                const [_chunkId, status, data] = value as IterableChunk;
-
-                switch (status) {
-                  case ASYNC_ITERABLE_STATUS_VALUE:
-                    return {
-                      done: false,
-                      value: decode(data),
-                    };
-                  case ASYNC_ITERABLE_STATUS_RETURN:
-                    controllers.delete(chunkId);
-                    return {
-                      done: true,
-                      value: decode(data),
-                    };
-                  case ASYNC_ITERABLE_STATUS_ERROR:
-                    controllers.delete(chunkId);
-                    throw (
-                      opts.formatError?.({ error: data }) ??
-                      new AsyncError(data)
-                    );
-                }
-              },
-              return: async () => {
+        const reader = stream.readable.getReader();
+        const iterator: AsyncIterator<unknown> = {
+          next: async () => {
+            const { done, value } = await reader.read();
+            if (value instanceof StreamInterruptedError) {
+              throw value;
+            }
+            if (done) {
+              controllers.delete(chunkId);
+              maybeAbort();
+
+              return {
+                done: true,
+                value: undefined,
+              };
+            }
+
+            const [_chunkId, status, data] = value as IterableChunk;
+
+            switch (status) {
+              case ASYNC_ITERABLE_STATUS_VALUE:
+                return {
+                  done: false,
+                  value: decode(data),
+                };
+              case ASYNC_ITERABLE_STATUS_RETURN:
                 controllers.delete(chunkId);
+                maybeAbort();
+
                 return {
                   done: true,
-                  value: undefined,
+                  value: decode(data),
                 };
-              },
+              case ASYNC_ITERABLE_STATUS_ERROR:
+                controllers.delete(chunkId);
+                maybeAbort();
+
+                throw (
+                  opts.formatError?.({ error: data }) ?? new AsyncError(data)
+                );
+            }
+          },
+          return: async () => {
+            controllers.delete(chunkId);
+            maybeAbort();
+
+            return {
+              done: true,
+              value: undefined,
             };
-            return iterator;
           },
         };
+        return {
+          [Symbol.asyncIterator]: () => iterator,
+        };
       }
     }
   }
@@ -571,19 +591,29 @@ export async function jsonlStreamConsumer<THead>(opts: {
             headDeferred.resolve(head as THead);
             headDeferred = null;
 
-            controllers.activate();
             return;
           }
           const chunk = chunkOrHead as ChunkData;
           const [idx] = chunk;
 
           // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          const controller = controllers.get(idx)!;
-          controller.enqueue(chunk);
+          let readController = controllers.get(idx)!;
+          if (!readController) {
+            let deferred = chunkDeferred.get(idx);
+            if (!deferred) {
+              deferred = createDeferred();
+              chunkDeferred.set(idx, deferred);
+            }
+            readController = await deferred.promise;
+          }
+          readController.enqueue(chunk);
         },
         close: closeOrAbort,
         abort: closeOrAbort,
       }),
+      {
+        signal: opts.abortController.signal,
+      },
     )
     .catch((error) => {
       opts.onError?.({ error });

package/src/unstable-core-do-not-import/stream/sse.ts

@@ -16,7 +16,7 @@ type Deserialize = (value: any) => any;
 /**
  * @internal
  */
-export interface PingOptions {
+export interface SSEPingOptions {
   /**
    * Enable ping comments sent from the server
    * @default false
@@ -29,15 +29,22 @@ export interface PingOptions {
   intervalMs?: number;
 }
 
+export interface SSEClientOptions {
+  /**
+   * Timeout and reconnect after inactivity in milliseconds
+   * @default undefined
+   */
+  reconnectAfterInactivityMs?: number;
+}
+
 export interface SSEStreamProducerOptions<TValue = unknown> {
   serialize?: Serialize;
   data: AsyncIterable<TValue>;
-  abortCtrl: AbortController;
+
   maxDepth?: number;
-  ping?: PingOptions;
+  ping?: SSEPingOptions;
   /**
    * Maximum duration in milliseconds for the request before ending the stream
-   * Only useful for serverless runtimes
    * @default undefined
    */
   maxDurationMs?: number;
@@ -48,10 +55,16 @@ export interface SSEStreamProducerOptions<TValue = unknown> {
    */
   emitAndEndImmediately?: boolean;
   formatError?: (opts: { error: unknown }) => unknown;
+  /**
+   * Client-specific options - these will be sent to the client as part of the first message
+   * @default {}
+   */
+  client?: SSEClientOptions;
 }
 
 const PING_EVENT = 'ping';
 const SERIALIZED_ERROR_EVENT = 'serialized-error';
+const CONNECTED_EVENT = 'connected';
 
 type SSEvent = Partial<{
   id: string;
@@ -67,14 +80,28 @@ export function sseStreamProducer<TValue = unknown>(
   opts: SSEStreamProducerOptions<TValue>,
 ) {
   const stream = createReadableStream<SSEvent>();
-  stream.controller.enqueue({ comment: 'connected' });
 
   const { serialize = identity } = opts;
 
-  const ping: Required<PingOptions> = {
+  const ping: Required<SSEPingOptions> = {
     enabled: opts.ping?.enabled ?? false,
     intervalMs: opts.ping?.intervalMs ?? 1000,
   };
+  const client: SSEClientOptions = opts.client ?? {};
+
+  stream.controller.enqueue({
+    event: CONNECTED_EVENT,
+    data: JSON.stringify(client),
+  });
+  if (
+    ping.enabled &&
+    client.reconnectAfterInactivityMs &&
+    ping.intervalMs > client.reconnectAfterInactivityMs
+  ) {
+    throw new Error(
+      `Ping interval must be less than client reconnect interval to prevent unnecessary reconnection - ping.intervalMs: ${ping.intervalMs} client.reconnectAfterInactivityMs: ${client.reconnectAfterInactivityMs}`,
+    );
+  }
 
   run(async () => {
     type TIteratorValue = Awaited<TValue> | typeof PING_SYM;
@@ -85,7 +112,6 @@ export function sseStreamProducer<TValue = unknown>(
       iterable = takeWithGrace(iterable, {
         count: 1,
         gracePeriodMs: 1,
-        abortCtrl: opts.abortCtrl,
       });
     }
 
@@ -96,7 +122,6 @@ export function sseStreamProducer<TValue = unknown>(
     ) {
       iterable = withMaxDuration(iterable, {
         maxDurationMs: opts.maxDurationMs,
-        abortCtrl: opts.abortCtrl,
       });
     }
 
@@ -191,11 +216,6 @@ interface ConsumerStreamResultError<TConfig extends ConsumerConfig>
   error: TConfig['error'];
 }
 
-interface ConsumerStreamResultOpened<TConfig extends ConsumerConfig>
-  extends ConsumerStreamResultBase<TConfig> {
-  type: 'opened';
-}
-
 interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig>
   extends ConsumerStreamResultBase<TConfig> {
   type: 'connecting';
@@ -204,20 +224,26 @@ interface ConsumerStreamResultConnecting<TConfig extends ConsumerConfig>
 interface ConsumerStreamResultTimeout<TConfig extends ConsumerConfig>
   extends ConsumerStreamResultBase<TConfig> {
   type: 'timeout';
+  ms: number;
 }
-
 interface ConsumerStreamResultPing<TConfig extends ConsumerConfig>
   extends ConsumerStreamResultBase<TConfig> {
   type: 'ping';
 }
 
+interface ConsumerStreamResultConnected<TConfig extends ConsumerConfig>
+  extends ConsumerStreamResultBase<TConfig> {
+  type: 'connected';
+  options: SSEClientOptions;
+}
+
 type ConsumerStreamResult<TConfig extends ConsumerConfig> =
   | ConsumerStreamResultData<TConfig>
   | ConsumerStreamResultError<TConfig>
-  | ConsumerStreamResultOpened<TConfig>
   | ConsumerStreamResultConnecting<TConfig>
   | ConsumerStreamResultTimeout<TConfig>
-  | ConsumerStreamResultPing<TConfig>;
+  | ConsumerStreamResultPing<TConfig>
+  | ConsumerStreamResultConnected<TConfig>;
 
 export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
   url: () => MaybePromise<string>;
@@ -227,10 +253,6 @@ export interface SSEStreamConsumerOptions<TConfig extends ConsumerConfig> {
   signal: AbortSignal;
   deserialize?: Deserialize;
   EventSource: TConfig['EventSource'];
-  /**
-   * Reconnect after inactivity in milliseconds
-   */
-  reconnectAfterInactivityMs?: number;
 }
 
 interface ConsumerConfig {
@@ -272,6 +294,8 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
 ): AsyncIterable<ConsumerStreamResult<TConfig>> {
   const { deserialize = (v) => v } = opts;
 
+  let clientOptions: SSEClientOptions = {};
+
   const signal = opts.signal;
 
   let _es: InstanceType<TConfig['EventSource']> | null = null;
@@ -290,9 +314,15 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
           eventSource: _es,
           event: null,
         });
-        eventSource.addEventListener('open', () => {
+
+        eventSource.addEventListener(CONNECTED_EVENT, (_msg) => {
+          const msg = _msg as EventSourceLike.MessageEvent;
+          const options: SSEClientOptions = JSON.parse(msg.data);
+
+          clientOptions = options;
           controller.enqueue({
-            type: 'opened',
+            type: 'connected',
+            options,
             eventSource,
           });
         });
@@ -376,10 +406,11 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
         async next() {
           let promise = stream.reader.read();
 
-          if (opts.reconnectAfterInactivityMs) {
+          const timeoutMs = clientOptions.reconnectAfterInactivityMs;
+          if (timeoutMs) {
             promise = withTimeout({
               promise,
-              timeoutMs: opts.reconnectAfterInactivityMs,
+              timeoutMs,
               onTimeout: async () => {
                 // Close and release old reader
                 await stream.cancel();
@@ -390,6 +421,7 @@ export function sseStreamConsumer<TConfig extends ConsumerConfig>(
                 return {
                   value: {
                     type: 'timeout',
+                    ms: timeoutMs,
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                     eventSource: _es!,
                   },