openai
Version:
The official TypeScript library for the OpenAI API
308 lines • 14.1 kB
JavaScript
var _EventStream_instances, _EventStream_connectedPromise, _EventStream_resolveConnectedPromise, _EventStream_rejectConnectedPromise, _EventStream_endPromise, _EventStream_resolveEndPromise, _EventStream_rejectEndPromise, _EventStream_listeners, _EventStream_abortListeners, _EventStream_ended, _EventStream_errored, _EventStream_aborted, _EventStream_catchingPromiseCreated, _EventStream_removeAbortListeners, _EventStream_handleError;
import { __classPrivateFieldGet, __classPrivateFieldSet } from "../internal/tslib.mjs";
import { APIUserAbortError, OpenAIError } from "../error.mjs";
export class EventStream {
constructor() {
_EventStream_instances.add(this);
this.controller = new AbortController();
_EventStream_connectedPromise.set(this, void 0);
_EventStream_resolveConnectedPromise.set(this, () => { });
_EventStream_rejectConnectedPromise.set(this, () => { });
_EventStream_endPromise.set(this, void 0);
_EventStream_resolveEndPromise.set(this, () => { });
_EventStream_rejectEndPromise.set(this, () => { });
_EventStream_listeners.set(this, {});
_EventStream_abortListeners.set(this, []);
_EventStream_ended.set(this, false);
_EventStream_errored.set(this, false);
_EventStream_aborted.set(this, false);
_EventStream_catchingPromiseCreated.set(this, false);
__classPrivateFieldSet(this, _EventStream_connectedPromise, new Promise((resolve, reject) => {
__classPrivateFieldSet(this, _EventStream_resolveConnectedPromise, resolve, "f");
__classPrivateFieldSet(this, _EventStream_rejectConnectedPromise, reject, "f");
}), "f");
__classPrivateFieldSet(this, _EventStream_endPromise, new Promise((resolve, reject) => {
__classPrivateFieldSet(this, _EventStream_resolveEndPromise, resolve, "f");
__classPrivateFieldSet(this, _EventStream_rejectEndPromise, reject, "f");
}), "f");
// Don't let these promises cause unhandled rejection errors.
// we will manually cause an unhandled rejection error later
// if the user hasn't registered any error listener or called
// any promise-returning method.
__classPrivateFieldGet(this, _EventStream_connectedPromise, "f").catch(() => { });
__classPrivateFieldGet(this, _EventStream_endPromise, "f").catch(() => { });
}
_run(executor) {
// Unfortunately if we call `executor()` immediately we get runtime errors about
// references to `this` before the `super()` constructor call returns.
setTimeout(() => {
Promise.resolve()
.then(executor)
.then(() => {
try {
this._emitFinal();
}
catch (error) {
__classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).call(this, error);
return;
}
this._emit('end');
}, __classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_handleError).bind(this));
}, 0);
}
_connected() {
if (this.ended)
return;
__classPrivateFieldGet(this, _EventStream_resolveConnectedPromise, "f").call(this);
this._emit('connect');
}
get ended() {
return __classPrivateFieldGet(this, _EventStream_ended, "f");
}
get errored() {
return __classPrivateFieldGet(this, _EventStream_errored, "f");
}
get aborted() {
return __classPrivateFieldGet(this, _EventStream_aborted, "f");
}
abort() {
this.controller.abort();
}
_listenForAbort(signal) {
if (!signal || this.ended)
return;
if (signal.aborted) {
this.controller.abort();
return;
}
const listener = () => this.controller.abort();
signal.addEventListener('abort', listener, { once: true });
__classPrivateFieldGet(this, _EventStream_abortListeners, "f").push({ signal, listener });
}
/**
* Adds the listener function to the end of the listeners array for the event.
* No checks are made to see if the listener has already been added. Multiple calls passing
* the same combination of event and listener will result in the listener being added, and
* called, multiple times.
* @returns this ChatCompletionStream, so that calls can be chained
*/
on(event, listener) {
const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = []);
listeners.push({ listener });
return this;
}
/**
* Removes the specified listener from the listener array for the event.
* off() will remove, at most, one instance of a listener from the listener array. If any single
* listener has been added multiple times to the listener array for the specified event, then
* off() must be called multiple times to remove each instance.
* @returns this ChatCompletionStream, so that calls can be chained
*/
off(event, listener) {
const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
if (!listeners)
return this;
const index = listeners.findIndex((l) => l.listener === listener);
if (index >= 0)
listeners.splice(index, 1);
return this;
}
/**
* Adds a one-time listener function for the event. The next time the event is triggered,
* this listener is removed and then invoked.
* @returns this ChatCompletionStream, so that calls can be chained
*/
once(event, listener) {
const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event] || (__classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = []);
listeners.push({ listener, once: true });
return this;
}
/**
* This is similar to `.once()`, but returns a Promise that resolves the next time
* the event is triggered, instead of calling a listener callback.
* @returns a Promise that resolves the next time given event is triggered,
* or rejects if an error is emitted. (If you request the 'error' event,
* returns a promise that resolves with the error).
*
* Example:
*
* const message = await stream.emitted('message') // rejects if the stream errors
*/
emitted(event) {
return new Promise((resolve, reject) => {
__classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
if (event !== 'error')
this.once('error', reject);
this.once(event, resolve);
});
}
/**
* Returns an async iterator that yields every time the event is triggered.
* The iterator ends when the stream ends and rejects if the stream errors
* or is aborted. If you request the 'error' or 'abort' event, the iterator
* yields that event instead of rejecting.
*
* Example:
*
* for await (const [message] of stream.events('message')) {
* await processMessage(message);
* }
*/
events(event) {
const pushQueue = [];
const readQueue = [];
let ended = this.ended;
let failure;
let failureDelivered = false;
const doneResult = () => ({ value: undefined, done: true });
const finishReaders = () => {
while (readQueue.length) {
readQueue.shift().resolve(doneResult());
}
};
const rejectReader = () => {
if (!failure || failureDelivered || !readQueue.length)
return;
failureDelivered = true;
readQueue.shift().reject(failure);
};
const cleanup = () => {
this.off(event, onEvent);
this.off('end', onEnd);
if (event !== 'error')
this.off('error', onFailure);
if (event !== 'abort')
this.off('abort', onFailure);
};
const onEvent = (...args) => {
if (ended)
return;
const reader = readQueue.shift();
if (reader) {
reader.resolve({ value: args, done: false });
}
else {
pushQueue.push(args);
}
};
const onFailure = (error) => {
failure = error;
if (!pushQueue.length)
rejectReader();
};
const onEnd = () => {
ended = true;
cleanup();
if (!pushQueue.length) {
rejectReader();
finishReaders();
}
};
if (!ended) {
this.on(event, onEvent);
this.on('end', onEnd);
if (event !== 'error')
this.on('error', onFailure);
if (event !== 'abort')
this.on('abort', onFailure);
}
return {
next: () => {
const value = pushQueue.shift();
if (value)
return Promise.resolve({ value, done: false });
if (failure && !failureDelivered) {
failureDelivered = true;
return Promise.reject(failure);
}
if (ended)
return Promise.resolve(doneResult());
return new Promise((resolve, reject) => {
readQueue.push({ resolve, reject });
});
},
return: () => {
ended = true;
pushQueue.length = 0;
cleanup();
finishReaders();
return Promise.resolve(doneResult());
},
[Symbol.asyncIterator]() {
return this;
},
};
}
async done() {
__classPrivateFieldSet(this, _EventStream_catchingPromiseCreated, true, "f");
await __classPrivateFieldGet(this, _EventStream_endPromise, "f");
}
_emit(event, ...args) {
// make sure we don't emit any events after end
if (__classPrivateFieldGet(this, _EventStream_ended, "f")) {
return;
}
if (event === 'end') {
__classPrivateFieldGet(this, _EventStream_instances, "m", _EventStream_removeAbortListeners).call(this);
__classPrivateFieldSet(this, _EventStream_ended, true, "f");
__classPrivateFieldGet(this, _EventStream_resolveEndPromise, "f").call(this);
}
const listeners = __classPrivateFieldGet(this, _EventStream_listeners, "f")[event];
if (listeners) {
__classPrivateFieldGet(this, _EventStream_listeners, "f")[event] = listeners.filter((l) => !l.once);
listeners.forEach(({ listener }) => listener(...args));
}
if (event === 'abort') {
const error = args[0];
if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !listeners?.length) {
Promise.reject(error);
}
__classPrivateFieldGet(this, _EventStream_rejectConnectedPromise, "f").call(this, error);
__classPrivateFieldGet(this, _EventStream_rejectEndPromise, "f").call(this, error);
this._emit('end');
return;
}
if (event === 'error') {
// NOTE: _emit('error', error) should only be called from #handleError().
const error = args[0];
if (!__classPrivateFieldGet(this, _EventStream_catchingPromiseCreated, "f") && !listeners?.length) {
// Trigger an unhandled rejection if the user hasn't registered any error handlers.
// If you are seeing stack traces here, make sure to handle errors via either:
// - runner.on('error', () => ...)
// - await runner.done()
// - await runner.finalChatCompletion()
// - etc.
Promise.reject(error);
}
__classPrivateFieldGet(this, _EventStream_rejectConnectedPromise, "f").call(this, error);
__classPrivateFieldGet(this, _EventStream_rejectEndPromise, "f").call(this, error);
this._emit('end');
}
}
_emitFinal() { }
}
_EventStream_connectedPromise = new WeakMap(), _EventStream_resolveConnectedPromise = new WeakMap(), _EventStream_rejectConnectedPromise = new WeakMap(), _EventStream_endPromise = new WeakMap(), _EventStream_resolveEndPromise = new WeakMap(), _EventStream_rejectEndPromise = new WeakMap(), _EventStream_listeners = new WeakMap(), _EventStream_abortListeners = new WeakMap(), _EventStream_ended = new WeakMap(), _EventStream_errored = new WeakMap(), _EventStream_aborted = new WeakMap(), _EventStream_catchingPromiseCreated = new WeakMap(), _EventStream_instances = new WeakSet(), _EventStream_removeAbortListeners = function _EventStream_removeAbortListeners() {
for (const { signal, listener } of __classPrivateFieldGet(this, _EventStream_abortListeners, "f").splice(0)) {
signal.removeEventListener('abort', listener);
}
}, _EventStream_handleError = function _EventStream_handleError(error) {
__classPrivateFieldSet(this, _EventStream_errored, true, "f");
if (error instanceof Error && error.name === 'AbortError') {
error = new APIUserAbortError();
}
if (error instanceof APIUserAbortError) {
__classPrivateFieldSet(this, _EventStream_aborted, true, "f");
return this._emit('abort', error);
}
if (error instanceof OpenAIError) {
return this._emit('error', error);
}
if (error instanceof Error) {
const openAIError = new OpenAIError(error.message);
// @ts-ignore
openAIError.cause = error;
return this._emit('error', openAIError);
}
return this._emit('error', new OpenAIError(String(error)));
};
//# sourceMappingURL=EventStream.mjs.map