FM / responses

/opt/canhelp/node_modules/openai/resources/responses/

/opt/canhelp/node_modules/openai/resources/responses

Name	Size	Mode	Actions
index.d.mts	286	0644	edit dl rm
index.d.mts.map	257	0644	edit dl rm
index.d.ts	282	0644	edit dl rm
index.d.ts.map	256	0644	edit dl rm
index.js	781	0644	edit dl rm
index.js.map	244	0644	edit dl rm
index.mjs	264	0644	edit dl rm
index.mjs.map	202	0644	edit dl rm
input-items.d.mts	2099	0644	edit dl rm
input-items.d.mts.map	1029	0644	edit dl rm
input-items.d.ts	2093	0644	edit dl rm
input-items.d.ts.map	1028	0644	edit dl rm
input-items.js	993	0644	edit dl rm
input-items.js.map	459	0644	edit dl rm
input-items.mjs	823	0644	edit dl rm
input-items.mjs.map	465	0644	edit dl rm
input-tokens.d.mts	6002	0644	edit dl rm
input-tokens.d.mts.map	1701	0644	edit dl rm
input-tokens.d.ts	5996	0644	edit dl rm
input-tokens.d.ts.map	1700	0644	edit dl rm
input-tokens.js	791	0644	edit dl rm
input-tokens.js.map	373	0644	edit dl rm
input-tokens.mjs	647	0644	edit dl rm
input-tokens.mjs.map	370	0644	edit dl rm
internal-base.d.mts	1770	0644	edit dl rm
internal-base.d.mts.map	1590	0644	edit dl rm
internal-base.d.ts	1765	0644	edit dl rm
internal-base.d.ts.map	1589	0644	edit dl rm
internal-base.js	1879	0644	edit dl rm
internal-base.js.map	1570	0644	edit dl rm
internal-base.mjs	1622	0644	edit dl rm
internal-base.mjs.map	1560	0644	edit dl rm
responses.d.mts	220556	0644	edit dl rm
responses.d.mts.map	72931	0644	edit dl rm
responses.d.ts	220542	0644	edit dl rm
responses.d.ts.map	72930	0644	edit dl rm
responses.js	4060	0644	edit dl rm
responses.js.map	2212	0644	edit dl rm
responses.mjs	3667	0644	edit dl rm
responses.mjs.map	2231	0644	edit dl rm
ws.d.mts	1443	0644	edit dl rm
ws.d.mts.map	701	0644	edit dl rm
ws.d.ts	1439	0644	edit dl rm
ws.d.ts.map	700	0644	edit dl rm
ws.js	6009	0644	edit dl rm
ws.js.map	5001	0644	edit dl rm
ws.mjs	5775	0644	edit dl rm
ws.mjs.map	5018	0644	edit dl rm

Edit: /opt/canhelp/node_modules/openai/resources/responses/ws.mjs (5775B)

// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
import * as WS from 'ws';
import { ResponsesEmitter, buildURL } from "./internal-base.mjs";
export class ResponsesWS extends ResponsesEmitter {
    constructor(client, options) {
        super();
        this.client = client;
        this.url = buildURL(client, {});
        this.socket = new WS.WebSocket(this.url, {
            ...options,
            headers: {
                ...this.authHeaders(),
                ...options?.headers,
            },
        });
        this.socket.on('message', (wsEvent) => {
            const event = (() => {
                try {
                    return JSON.parse(wsEvent.toString());
                }
                catch (err) {
                    this._onError(null, 'could not parse websocket event', err);
                    return null;
                }
            })();
            if (event) {
                this._emit('event', event);
                if (event.type === 'error') {
                    this._onError(event);
                }
                else {
                    // @ts-ignore TS isn't smart enough to get the relationship right here
                    this._emit(event.type, event);
                }
            }
        });
        this.socket.on('error', (err) => {
            this._onError(null, err.message, err);
        });
    }
    send(event) {
        try {
            this.socket.send(JSON.stringify(event));
        }
        catch (err) {
            this._onError(null, 'could not send data', err);
        }
    }
    close(props) {
        try {
            this.socket.close(props?.code ?? 1000, props?.reason ?? 'OK');
        }
        catch (err) {
            this._onError(null, 'could not close the connection', err);
        }
    }
    /**
     * Returns an async iterator over WebSocket lifecycle and message events,
     * providing an alternative to the event-based `.on()` API.
     * The iterator will exit if the socket closes but breaking out of the iterator
     * does not close the socket.
     *
     * @example
     * ```ts
     * for await (const event of connection.stream()) {
     *   switch (event.type) {
     *     case 'message':
     *       console.log('received:', event.message);
     *       break;
     *     case 'error':
     *       console.error(event.error);
     *       break;
     *     case 'close':
     *       console.log('connection closed');
     *       break;
     *   }
     * }
     * ```
     */
    stream() {
        return this[Symbol.asyncIterator]();
    }
    [Symbol.asyncIterator]() {
        // Two-queue async iterator: `queue` buffers incoming messages,
        // `resolvers` buffers waiting next() calls. A push wakes the
        // oldest next(); a next() drains the oldest message.
        const queue = [];
        const resolvers = [];
        let done = false;
        const push = (msg) => {
            queue.push(msg);
            resolvers.shift()?.();
        };
        const onEvent = (event) => {
            if (event.type === 'error')
                return; // handled by onEmitterError
            push({ type: 'message', message: event });
        };
        // Catches both API-level and socket-level errors via _onError → _emit('error')
        const onEmitterError = (err) => {
            push({ type: 'error', error: err });
        };
        const onOpen = () => {
            push({ type: 'open' });
        };
        const flushResolvers = () => {
            for (let resolver = resolvers.shift(); resolver; resolver = resolvers.shift()) {
                resolver();
            }
        };
        const onClose = () => {
            push({ type: 'close' });
            done = true;
            flushResolvers();
            cleanup();
        };
        const cleanup = () => {
            this.off('event', onEvent);
            this.off('error', onEmitterError);
            this.socket.off('open', onOpen);
            this.socket.off('close', onClose);
        };
        this.on('event', onEvent);
        this.on('error', onEmitterError);
        this.socket.on('open', onOpen);
        this.socket.on('close', onClose);
        switch (this.socket.readyState) {
            case WS.WebSocket.CONNECTING:
                push({ type: 'connecting' });
                break;
            case WS.WebSocket.OPEN:
                push({ type: 'open' });
                break;
            case WS.WebSocket.CLOSING:
                push({ type: 'closing' });
                break;
            case WS.WebSocket.CLOSED:
                push({ type: 'close' });
                done = true;
                cleanup();
                break;
        }
        const resolve = (res) => {
            if (queue.length > 0) {
                res({ value: queue.shift(), done: false });
            }
            else if (done) {
                res({ value: undefined, done: true });
            }
            else {
                return false;
            }
            return true;
        };
        const next = () => new Promise((res) => {
            if (resolve(res))
                return;
            resolvers.push(() => {
                resolve(res);
            });
        });
        return {
            next,
            return: () => {
                done = true;
                cleanup();
                flushResolvers();
                return Promise.resolve({ value: undefined, done: true });
            },
            [Symbol.asyncIterator]() {
                return this;
            },
        };
    }
    authHeaders() {
        return { Authorization: `Bearer ${this.client.apiKey}` };
        return {};
    }
}
//# sourceMappingURL=ws.mjs.map

cmd: