onIdleTimeout?: (error: Error) => void,

): StreamFn {

return (model, context, options) => {

const maybeStream = baseFn(model, context, options);

const createIdleTimeoutError = () =>

new Error(`LLM idle timeout (${Math.floor(timeoutMs / 1000)}s): no response from model`);

const streamAbortController = new AbortController();

const sourceSignal = options?.signal;

const abortStream = (reason?: unknown) => {

if (!streamAbortController.signal.aborted) {

streamAbortController.abort(reason);

}

};

const abortFromSourceSignal = () => abortStream(sourceSignal?.reason);

if (sourceSignal?.aborted) {

abortFromSourceSignal();

} else {

sourceSignal?.addEventListener("abort", abortFromSourceSignal, { once: true });

}

const cleanupSourceSignal = () => {

sourceSignal?.removeEventListener("abort", abortFromSourceSignal);

};

const wrappedOptions = {

...(options ?? {}),

signal: streamAbortController.signal,

} as typeof options;

const createTimeoutPromise = (setTimer: (timer: NodeJS.Timeout) => void): Promise<never> => {

return new Promise((_, reject) => {

const timer = setTimeout(() => {

const error = createIdleTimeoutError();

abortStream(error);

onIdleTimeout?.(error);

reject(error);

}, timeoutMs);

});

};

let maybeStream: ReturnType<StreamFn>;

try {

maybeStream = baseFn(model, context, wrappedOptions);

} catch (error) {

cleanupSourceSignal();

throw error;

}

const wrapStream = (stream: ReturnType<typeof streamSimple>) => {

const originalAsyncIterator = stream[Symbol.asyncIterator].bind(stream);

(stream as { [Symbol.asyncIterator]: typeof originalAsyncIterator })[Symbol.asyncIterator] =

if (result.done) {

clearTimer();

cleanupSourceSignal();

return result;

}

},

onReturn(streamIterator) {

clearTimer();

cleanupSourceSignal();

return streamIterator.return?.() ?? Promise.resolve({ done: true, value: undefined });

},

onThrow(streamIterator, error) {

clearTimer();

cleanupSourceSignal();

return streamIterator.throw?.(error) ?? Promise.reject(error);

},

});

},

(error) => {

clearStreamPromiseTimer();

cleanupSourceSignal();

throw error;

},

);