@agentica/core 0.31.2 → 0.31.3

package/lib/index.mjs

@@ -1095,6 +1095,138 @@ function cancelFunctionFromContext(ctx, reference) {
     ctx.dispatch(event);
 }
 
+class AsyncQueueClosedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AsyncQueueClosedError";
+    }
+}
+
+class AsyncQueue {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.closeResolvers = [];
+        this.emptyResolvers = [];
+        this.closed = false;
+    }
+    enqueue(item) {
+        if (this.closed) {
+            console.error(new AsyncQueueClosedError("Cannot enqueue item: queue is closed."));
+            return;
+        }
+        this.queue.push(item);
+        if (this.resolvers.length > 0) {
+            this.resolvers.shift()?.({
+                value: this.queue.shift(),
+                done: false
+            });
+        }
+    }
+    async dequeue() {
+        const item = (() => {
+            if (!this.isEmpty()) {
+                return {
+                    value: this.queue.shift(),
+                    done: false
+                };
+            }
+            if (this.isClosed()) {
+                return {
+                    value: undefined,
+                    done: true
+                };
+            }
+            return null;
+        })();
+        if (this.isEmpty() && this.emptyResolvers.length !== 0) {
+            this.emptyResolvers.forEach((resolve => resolve()));
+            this.emptyResolvers = [];
+        }
+        if (item !== null) {
+            return item;
+        }
+        return new Promise((resolve => this.resolvers.push(resolve)));
+    }
+    isEmpty() {
+        return this.queue.length === 0;
+    }
+    isClosed() {
+        return this.closed;
+    }
+    done() {
+        return this.isClosed() && this.isEmpty();
+    }
+    close() {
+        this.closed = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()?.({
+                value: undefined,
+                done: true
+            });
+        }
+        this.closeResolvers.forEach((resolve => resolve()));
+    }
+    async waitUntilEmpty() {
+        if (this.isEmpty()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve => {
+            this.emptyResolvers.push(resolve);
+        }));
+    }
+    async waitClosed() {
+        if (this.isClosed()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve => {
+            this.closeResolvers.push(resolve);
+        }));
+    }
+}
+
+class MPSC {
+    constructor() {
+        this.queue = new AsyncQueue;
+        this.consumer = new ReadableStream({
+            pull: async controller => {
+                const {value, done} = await this.queue.dequeue();
+                if (done === true) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+        });
+    }
+    produce(chunk) {
+        this.queue.enqueue(chunk);
+    }
+    close() {
+        this.queue.close();
+    }
+    done() {
+        return this.queue.done();
+    }
+    async waitClosed() {
+        await this.queue.waitClosed();
+    }
+    async waitUntilEmpty() {
+        await this.queue.waitUntilEmpty();
+    }
+}
+
+var index$2 = Object.freeze({
+    __proto__: null,
+    AsyncQueue,
+    AsyncQueueClosedError,
+    ChatGptCompletionMessageUtil,
+    MPSC,
+    StreamUtil,
+    streamDefaultReaderToAsyncGenerator,
+    toAsyncGenerator
+});
+
 async function call(ctx, operations) {
     const stream = await ctx.request("call", {
         messages: [ {
@@ -1123,8 +1255,49 @@ async function call(ctx, operations) {
         }))),
         tool_choice: "auto"
     });
-    const chunks = await StreamUtil.readAll(stream);
-    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+    const selectContext = [];
+    const nullableCompletion = await StreamUtil.reduce(stream, (async (accPromise, chunk) => {
+        const acc = await accPromise;
+        const registerContext = choices => {
+            for (const choice of choices) {
+                if (choice.finish_reason != null) {
+                    selectContext[choice.index]?.mpsc.close();
+                    continue;
+                }
+                if (choice.delta.content == null) {
+                    continue;
+                }
+                if (selectContext[choice.index] != null) {
+                    selectContext[choice.index].content += choice.delta.content;
+                    selectContext[choice.index].mpsc.produce(choice.delta.content);
+                    continue;
+                }
+                const mpsc = new MPSC;
+                selectContext[choice.index] = {
+                    content: choice.delta.content,
+                    mpsc
+                };
+                mpsc.produce(choice.delta.content);
+                const event = createAssistantMessageEvent({
+                    stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
+                    done: () => mpsc.done(),
+                    get: () => selectContext[choice.index]?.content ?? "",
+                    join: async () => {
+                        await mpsc.waitClosed();
+                        return selectContext[choice.index].content;
+                    }
+                });
+                ctx.dispatch(event);
+            }
+        };
+        if (acc.object === "chat.completion.chunk") {
+            registerContext([ acc, chunk ].flatMap((v => v.choices)));
+            return ChatGptCompletionMessageUtil.merge([ acc, chunk ]);
+        }
+        registerContext(chunk.choices);
+        return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
+    }));
+    const completion = nullableCompletion;
     const executes = [];
     const retry = ctx.config?.retry ?? AgenticaConstant.RETRY;
     for (const choice of completion.choices) {
@@ -1145,16 +1318,6 @@ async function call(ctx, operations) {
                 }
             }
         }
-        if (choice.message.role === "assistant" && choice.message.content != null && choice.message.content.length !== 0) {
-            const text = choice.message.content;
-            const event = createAssistantMessageEvent({
-                get: () => text,
-                done: () => true,
-                stream: toAsyncGenerator(text),
-                join: async () => Promise.resolve(text)
-            });
-            ctx.dispatch(event);
-        }
     }
     return executes;
 }
@@ -1665,127 +1828,6 @@ function emendMessages$1(failures) {
     } ])).flat();
 }
 
-class AsyncQueueClosedError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "AsyncQueueClosedError";
-    }
-}
-
-class AsyncQueue {
-    constructor() {
-        this.queue = [];
-        this.resolvers = [];
-        this.closeResolvers = [];
-        this.emptyResolvers = [];
-        this.closed = false;
-    }
-    enqueue(item) {
-        if (this.closed) {
-            console.error(new AsyncQueueClosedError("Cannot enqueue item: queue is closed."));
-            return;
-        }
-        this.queue.push(item);
-        if (this.resolvers.length > 0) {
-            this.resolvers.shift()?.({
-                value: this.queue.shift(),
-                done: false
-            });
-        }
-    }
-    async dequeue() {
-        const item = (() => {
-            if (!this.isEmpty()) {
-                return {
-                    value: this.queue.shift(),
-                    done: false
-                };
-            }
-            if (this.isClosed()) {
-                return {
-                    value: undefined,
-                    done: true
-                };
-            }
-            return null;
-        })();
-        if (this.isEmpty() && this.emptyResolvers.length !== 0) {
-            this.emptyResolvers.forEach((resolve => resolve()));
-            this.emptyResolvers = [];
-        }
-        if (item !== null) {
-            return item;
-        }
-        return new Promise((resolve => this.resolvers.push(resolve)));
-    }
-    isEmpty() {
-        return this.queue.length === 0;
-    }
-    isClosed() {
-        return this.closed;
-    }
-    done() {
-        return this.isClosed() && this.isEmpty();
-    }
-    close() {
-        this.closed = true;
-        while (this.resolvers.length > 0) {
-            this.resolvers.shift()?.({
-                value: undefined,
-                done: true
-            });
-        }
-        this.closeResolvers.forEach((resolve => resolve()));
-    }
-    async waitUntilEmpty() {
-        if (this.isEmpty()) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve => {
-            this.emptyResolvers.push(resolve);
-        }));
-    }
-    async waitClosed() {
-        if (this.isClosed()) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve => {
-            this.closeResolvers.push(resolve);
-        }));
-    }
-}
-
-class MPSC {
-    constructor() {
-        this.queue = new AsyncQueue;
-        this.consumer = new ReadableStream({
-            pull: async controller => {
-                const {value, done} = await this.queue.dequeue();
-                if (done === true) {
-                    controller.close();
-                    return;
-                }
-                controller.enqueue(value);
-            }
-        });
-    }
-    produce(chunk) {
-        this.queue.enqueue(chunk);
-    }
-    close() {
-        this.queue.close();
-    }
-    done() {
-        return this.queue.done();
-    }
-    async waitClosed() {
-        await this.queue.waitClosed();
-    }
-    async waitUntilEmpty() {
-        await this.queue.waitUntilEmpty();
-    }
-}
-
 async function describe(ctx, histories) {
     if (histories.length === 0) {
         return;
@@ -2736,8 +2778,49 @@ async function step(ctx, operations, retry, failures) {
         } ],
         tool_choice: retry === 0 ? "auto" : "required"
     });
-    const chunks = await StreamUtil.readAll(completionStream);
-    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+    const selectContext = [];
+    const nullableCompletion = await StreamUtil.reduce(completionStream, (async (accPromise, chunk) => {
+        const acc = await accPromise;
+        const registerContext = choices => {
+            for (const choice of choices) {
+                if (choice.finish_reason != null) {
+                    selectContext[choice.index]?.mpsc.close();
+                    continue;
+                }
+                if (choice.delta.content == null) {
+                    continue;
+                }
+                if (selectContext[choice.index] != null) {
+                    selectContext[choice.index].content += choice.delta.content;
+                    selectContext[choice.index].mpsc.produce(choice.delta.content);
+                    continue;
+                }
+                const mpsc = new MPSC;
+                selectContext[choice.index] = {
+                    content: choice.delta.content,
+                    mpsc
+                };
+                mpsc.produce(choice.delta.content);
+                const event = createAssistantMessageEvent({
+                    stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
+                    done: () => mpsc.done(),
+                    get: () => selectContext[choice.index]?.content ?? "",
+                    join: async () => {
+                        await mpsc.waitClosed();
+                        return selectContext[choice.index].content;
+                    }
+                });
+                ctx.dispatch(event);
+            }
+        };
+        if (acc.object === "chat.completion.chunk") {
+            registerContext([ acc, chunk ].flatMap((v => v.choices)));
+            return ChatGptCompletionMessageUtil.merge([ acc, chunk ]);
+        }
+        registerContext(chunk.choices);
+        return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
+    }));
+    const completion = nullableCompletion;
     if (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)) {
         const failures = [];
         for (const choice of completion.choices) {
@@ -2845,15 +2928,6 @@ async function step(ctx, operations, retry, failures) {
                 }
             }
         }
-        if (choice.message.role === "assistant" && choice.message.content != null && choice.message.content.length !== 0) {
-            const event = createAssistantMessageEvent({
-                stream: toAsyncGenerator(choice.message.content),
-                join: async () => Promise.resolve(choice.message.content),
-                done: () => true,
-                get: () => choice.message.content
-            });
-            ctx.dispatch(event);
-        }
     }
 }
 
@@ -3210,7 +3284,7 @@ class Agentica {
     }
 }
 
-var index$2 = Object.freeze({
+var index$1 = Object.freeze({
     __proto__: null,
     createAssistantMessageEvent,
     createAssistantMessageHistory,
@@ -41888,7 +41962,7 @@ async function validateMcpController(props) {
     };
 }
 
-var index$1 = Object.freeze({
+var index = Object.freeze({
     __proto__: null,
     ChatGptDescribeFunctionAgent,
     call,
@@ -42082,16 +42156,5 @@ class MicroAgentica {
     }
 }
 
-var index = Object.freeze({
-    __proto__: null,
-    AsyncQueue,
-    AsyncQueueClosedError,
-    ChatGptCompletionMessageUtil,
-    MPSC,
-    StreamUtil,
-    streamDefaultReaderToAsyncGenerator,
-    toAsyncGenerator
-});
-
-export { Agentica, AgenticaDefaultPrompt, AgenticaSystemPrompt, AgenticaTokenUsage, MicroAgentica, assertHttpController, assertHttpLlmApplication, assertMcpController, index$2 as factory, index$1 as orchestrate, index as utils, validateHttpController, validateHttpLlmApplication, validateMcpController, write };
+export { Agentica, AgenticaDefaultPrompt, AgenticaSystemPrompt, AgenticaTokenUsage, MicroAgentica, assertHttpController, assertHttpLlmApplication, assertMcpController, index$1 as factory, index as orchestrate, index$2 as utils, validateHttpController, validateHttpLlmApplication, validateMcpController, write };
 //# sourceMappingURL=index.mjs.map