@theia/ai-openai 1.58.3 → 1.59.0-next.72

package/src/node/openai-streaming-iterator.spec.ts

@@ -0,0 +1,254 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { StreamingAsyncIterator } from './openai-streaming-iterator';
+import { ChatCompletionStream } from 'openai/lib/ChatCompletionStream';
+import { CancellationTokenSource, CancellationError } from '@theia/core';
+import { LanguageModelStreamResponsePart } from '@theia/ai-core';
+import { EventEmitter } from 'events';
+
+describe('StreamingAsyncIterator', () => {
+    let mockStream: ChatCompletionStream & EventEmitter;
+    let iterator: StreamingAsyncIterator;
+    let cts: CancellationTokenSource;
+    const consoleError = console.error;
+
+    beforeEach(() => {
+        mockStream = new EventEmitter() as ChatCompletionStream & EventEmitter;
+        mockStream.abort = sinon.stub();
+
+        cts = new CancellationTokenSource();
+    });
+
+    afterEach(() => {
+        if (iterator) {
+            iterator.dispose();
+        }
+        cts.dispose();
+        console.error = consoleError;
+    });
+
+    function createIterator(withCancellationToken = false): StreamingAsyncIterator {
+        return new StreamingAsyncIterator(mockStream, withCancellationToken ? cts.token : undefined);
+    }
+
+    it('should yield messages in the correct order when consumed immediately', async () => {
+        iterator = createIterator();
+
+        setTimeout(() => {
+            mockStream.emit('chunk', { choices: [{ delta: { content: 'Hello' } }] });
+            mockStream.emit('chunk', { choices: [{ delta: { content: ' ' } }] });
+            mockStream.emit('chunk', { choices: [{ delta: { content: 'World' } }] });
+            mockStream.emit('end');
+        }, 10);
+
+        const results: LanguageModelStreamResponsePart[] = [];
+
+        while (true) {
+            const { value, done } = await iterator.next();
+            if (done) {
+                break;
+            }
+            results.push(value);
+        }
+
+        expect(results).to.deep.equal([
+            { content: 'Hello' },
+            { content: ' ' },
+            { content: 'World' }
+        ]);
+    });
+
+    it('should buffer messages if consumer is slower (messages arrive before .next() is called)', async () => {
+        iterator = createIterator();
+
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'A' } }] });
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'B' } }] });
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'C' } }] });
+        mockStream.emit('end');
+
+        const results: string[] = [];
+        while (true) {
+            const { value, done } = await iterator.next();
+            if (done) {
+                break;
+            }
+            results.push(value.content ?? '');
+        }
+
+        expect(results).to.deep.equal(['A', 'B', 'C']);
+    });
+
+    it('should resolve queued next() call when a message arrives (consumer is waiting first)', async () => {
+        iterator = createIterator();
+
+        const nextPromise = iterator.next();
+
+        setTimeout(() => {
+            mockStream.emit('chunk', { choices: [{ delta: { content: 'Hello from queue' } }] });
+            mockStream.emit('end');
+        }, 10);
+
+        const first = await nextPromise;
+        expect(first.done).to.be.false;
+        expect(first.value.content).to.equal('Hello from queue');
+
+        const second = await iterator.next();
+        expect(second.done).to.be.true;
+        expect(second.value).to.be.undefined;
+    });
+
+    it('should handle the end event correctly', async () => {
+        iterator = createIterator();
+
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'EndTest1' } }] });
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'EndTest2' } }] });
+        mockStream.emit('end');
+
+        const results: string[] = [];
+        while (true) {
+            const { value, done } = await iterator.next();
+            if (done) {
+                break;
+            }
+            results.push(value.content ?? '');
+        }
+
+        expect(results).to.deep.equal(['EndTest1', 'EndTest2']);
+    });
+
+    it('should reject pending .next() call with an error if error event occurs', async () => {
+        iterator = createIterator();
+
+        const pendingNext = iterator.next();
+
+        // Suppress console.error output
+        console.error = () => { };
+
+        const error = new Error('Stream error occurred');
+        mockStream.emit('error', error);
+
+        try {
+            await pendingNext;
+            expect.fail('The promise should have been rejected with an error.');
+        } catch (err) {
+            expect(err).to.equal(error);
+        }
+    });
+
+    it('should reject pending .next() call with a CancellationError if "abort" event occurs', async () => {
+        iterator = createIterator();
+
+        const pendingNext = iterator.next();
+
+        // Suppress console.error output
+        console.error = () => { };
+
+        mockStream.emit('abort');
+
+        try {
+            await pendingNext;
+            expect.fail('The promise should have been rejected with a CancellationError.');
+        } catch (err) {
+            expect(err).to.be.instanceOf(CancellationError);
+        }
+    });
+
+    it('should call stream.abort() when cancellation token is triggered', async () => {
+        iterator = createIterator(true);
+
+        cts.cancel();
+
+        sinon.assert.calledOnce(mockStream.abort as sinon.SinonSpy);
+    });
+
+    it('should not lose unconsumed messages after disposal, but no new ones arrive', async () => {
+        iterator = createIterator();
+
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'Msg1' } }] });
+        mockStream.emit('chunk', { choices: [{ delta: { content: 'Msg2' } }] });
+
+        iterator.dispose();
+
+        let result = await iterator.next();
+        expect(result.done).to.be.false;
+        expect(result.value.content).to.equal('Msg1');
+
+        result = await iterator.next();
+        expect(result.done).to.be.false;
+        expect(result.value.content).to.equal('Msg2');
+
+        result = await iterator.next();
+        expect(result.done).to.be.true;
+        expect(result.value).to.be.undefined;
+    });
+
+    it('should reject all pending requests with an error if disposal occurs after stream error', async () => {
+        iterator = createIterator();
+
+        const pendingNext1 = iterator.next();
+        const pendingNext2 = iterator.next();
+
+        // Suppress console.error output
+        console.error = () => { };
+
+        const error = new Error('Critical error');
+        mockStream.emit('error', error);
+
+        try {
+            await pendingNext1;
+            expect.fail('expected to be rejected');
+        } catch (err) {
+            expect(err).to.equal(error);
+        }
+
+        try {
+            await pendingNext2;
+            expect.fail('expected to be rejected');
+        } catch (err) {
+            expect(err).to.equal(error);
+        }
+    });
+
+    it('should handle receiving a "message" event with role="tool"', async () => {
+        iterator = createIterator();
+
+        setTimeout(() => {
+            mockStream.emit('message', {
+                role: 'tool',
+                tool_call_id: 'tool-123',
+                content: ['Part1', 'Part2']
+            });
+            mockStream.emit('end');
+        }, 10);
+
+        const results: LanguageModelStreamResponsePart[] = [];
+        for await (const part of iterator) {
+            results.push(part);
+        }
+
+        expect(results).to.have.lengthOf(1);
+        expect(results[0].tool_calls).to.deep.equal([
+            {
+                id: 'tool-123',
+                finished: true,
+                result: 'Part1Part2'
+            }
+        ]);
+    });
+});

package/src/node/openai-streaming-iterator.ts

@@ -0,0 +1,124 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { LanguageModelStreamResponsePart } from '@theia/ai-core';
+import { CancellationError, CancellationToken, Disposable, DisposableCollection } from '@theia/core';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { ChatCompletionStream, ChatCompletionStreamEvents } from 'openai/lib/ChatCompletionStream';
+
+type IterResult = IteratorResult<LanguageModelStreamResponsePart>;
+
+export class StreamingAsyncIterator implements AsyncIterableIterator<LanguageModelStreamResponsePart>, Disposable {
+    protected readonly requestQueue = new Array<Deferred<IterResult>>();
+    protected readonly messageCache = new Array<LanguageModelStreamResponsePart>();
+    protected done = false;
+    protected terminalError: Error | undefined = undefined;
+    protected readonly toDispose = new DisposableCollection();
+    constructor(protected readonly stream: ChatCompletionStream, cancellationToken?: CancellationToken) {
+        this.registerStreamListener('error', error => {
+            console.error('Error in OpenAI chat completion stream:', error);
+            this.terminalError = error;
+            this.dispose();
+        });
+        this.registerStreamListener('abort', () => {
+            this.terminalError = new CancellationError();
+            this.dispose();
+        }, true);
+        this.registerStreamListener('message', message => {
+            if (message.role === 'tool') {
+                this.handleIncoming({
+                    tool_calls: [{
+                        id: message.tool_call_id,
+                        finished: true,
+                        result: Array.isArray(message.content) ? message.content.join('') : message.content
+                    }]
+                });
+            }
+            console.debug('Received Open AI message', JSON.stringify(message));
+        });
+        this.registerStreamListener('end', () => {
+            this.dispose();
+        }, true);
+        this.registerStreamListener('chunk', chunk => {
+            this.handleIncoming({ ...chunk.choices[0]?.delta });
+        });
+        if (cancellationToken) {
+            this.toDispose.push(cancellationToken.onCancellationRequested(() => stream.abort()));
+        }
+    }
+
+    [Symbol.asyncIterator](): AsyncIterableIterator<LanguageModelStreamResponsePart> { return this; }
+
+    next(): Promise<IterResult> {
+        if (this.messageCache.length && this.requestQueue.length) {
+            throw new Error('Assertion error: cache and queue should not both be populated.');
+        }
+        // Deliver all the messages we got, even if we've since terminated.
+        if (this.messageCache.length) {
+            return Promise.resolve({
+                done: false,
+                value: this.messageCache.shift()!
+            });
+        } else if (this.terminalError) {
+            return Promise.reject(this.terminalError);
+        } else if (this.done) {
+            return Promise.resolve({
+                done: true,
+                value: undefined
+            });
+        } else {
+            const toQueue = new Deferred<IterResult>();
+            this.requestQueue.push(toQueue);
+            return toQueue.promise;
+        }
+    }
+
+    protected handleIncoming(message: LanguageModelStreamResponsePart): void {
+        if (this.messageCache.length && this.requestQueue.length) {
+            throw new Error('Assertion error: cache and queue should not both be populated.');
+        }
+        if (this.requestQueue.length) {
+            this.requestQueue.shift()!.resolve({
+                done: false,
+                value: message
+            });
+        } else {
+            this.messageCache.push(message);
+        }
+    }
+
+    protected registerStreamListener<Event extends keyof ChatCompletionStreamEvents>(eventType: Event, handler: ChatCompletionStreamEvents[Event], once?: boolean): void {
+        if (once) {
+            this.stream.once(eventType, handler);
+        } else {
+            this.stream.on(eventType, handler);
+        }
+        this.toDispose.push({ dispose: () => this.stream.off(eventType, handler) });
+    }
+
+    dispose(): void {
+        this.done = true;
+        this.toDispose.dispose();
+        // We will be receiving no more messages. Any outstanding requests have to be handled.
+        if (this.terminalError) {
+            this.requestQueue.forEach(request => request.reject(this.terminalError));
+        } else {
+            this.requestQueue.forEach(request => request.resolve({ done: true, value: undefined }));
+        }
+        // Leave the message cache alone - if it was populated, then the request queue was empty, but we'll still try to deliver the messages if asked.
+        this.requestQueue.length = 0;
+    }
+}

package/lib/package.spec.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=package.spec.d.ts.map

package/lib/package.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.spec.d.ts","sourceRoot":"","sources":["../src/package.spec.ts"],"names":[],"mappings":""}

package/lib/package.spec.js

@@ -1,26 +0,0 @@
-// *****************************************************************************
-// Copyright (C) 2024 EclipseSource GmbH and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-/* note: this bogus test file is required so that
-   we are able to run mocha unit tests on this
-   package, without having any actual unit tests in it.
-   This way a coverage report will be generated,
-   showing 0% coverage, instead of no report.
-   This file can be removed once we have real unit
-   tests in place. */
-describe('ai-openai package', () => {
-    it('support code coverage statistics', () => true);
-});
-//# sourceMappingURL=package.spec.js.map

package/lib/package.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.spec.js","sourceRoot":"","sources":["../src/package.spec.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,oDAAoD;AACpD,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAEhF;;;;;;qBAMqB;AAErB,QAAQ,CAAC,mBAAmB,EAAE,GAAG,EAAE;IAE/B,EAAE,CAAC,kCAAkC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;AACvD,CAAC,CAAC,CAAC"}

package/src/package.spec.ts

@@ -1,28 +0,0 @@
-// *****************************************************************************
-// Copyright (C) 2024 EclipseSource GmbH and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-/* note: this bogus test file is required so that
-   we are able to run mocha unit tests on this
-   package, without having any actual unit tests in it.
-   This way a coverage report will be generated,
-   showing 0% coverage, instead of no report.
-   This file can be removed once we have real unit
-   tests in place. */
-
-describe('ai-openai package', () => {
-
-    it('support code coverage statistics', () => true);
-});