@agentica/core 0.32.2 → 0.32.3-dev.2

package/src/utils/ChatGptCompletionStreamingUtil.ts

@@ -0,0 +1,90 @@
+import type { ChatCompletion, ChatCompletionChunk } from "openai/resources";
+
+import { ChatGptCompletionMessageUtil, MPSC, streamDefaultReaderToAsyncGenerator, StreamUtil, toAsyncGenerator } from ".";
+
+async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletionChunk>, eventProcessor: (props: {
+  stream: AsyncGenerator<string, undefined, undefined>;
+  done: () => boolean;
+  get: () => string;
+  join: () => Promise<string>;
+}) => void) {
+  const streamContext = new Map<number, { content: string; mpsc: MPSC<string> }>();
+
+  const nullableCompletion = await StreamUtil.reduce<ChatCompletionChunk, Promise<ChatCompletion>>(stream, async (accPromise, chunk) => {
+    const acc = await accPromise;
+    const registerContext = (
+      choices: ChatCompletionChunk.Choice[],
+    ) => {
+      for (const choice of choices) {
+        // Handle content first, even if finish_reason is present
+        if (choice.delta.content != null && choice.delta.content !== "") {
+          // Process content logic (moved up from below)
+          if (streamContext.has(choice.index)) {
+            const context = streamContext.get(choice.index)!;
+            context.content += choice.delta.content;
+            context.mpsc.produce(choice.delta.content);
+          } else {
+            const mpsc = new MPSC<string>();
+
+            streamContext.set(choice.index, {
+              content: choice.delta.content,
+              mpsc,
+            });
+            mpsc.produce(choice.delta.content);
+
+            eventProcessor({
+              stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
+              done: () => mpsc.done(),
+              get: () => streamContext.get(choice.index)?.content ?? "",
+              join: async () => {
+                await mpsc.waitClosed();
+                return streamContext.get(choice.index)!.content;
+              },
+            });
+          }
+        }
+        
+        // Handle finish_reason after content processing
+        if (choice.finish_reason != null) {
+          const context = streamContext.get(choice.index);
+          if (context != null) {
+            context.mpsc.close();
+          }
+        }
+      }
+    };
+    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);
+  });
+
+  if (nullableCompletion == null) {
+    throw new Error(
+      "StreamUtil.reduce did not produce a ChatCompletion. Possible causes: the input stream was empty, invalid, or closed prematurely. "
+      + "To debug: check that the stream is properly initialized and contains valid ChatCompletionChunk data. "
+      + "You may also enable verbose logging upstream to inspect the stream contents. "
+      + `Stream locked: ${stream.locked}.`,
+    );
+  }
+
+  if((nullableCompletion.object as string) === "chat.completion.chunk") {
+    const completion = ChatGptCompletionMessageUtil.merge([nullableCompletion as unknown as ChatCompletionChunk]);
+    completion.choices.forEach((choice) => {
+      if(choice.message.content != null && choice.message.content !== "") {
+        eventProcessor({
+          stream: toAsyncGenerator(choice.message.content),
+          done: () => true,
+          get: () => choice.message.content!,
+          join: async () => choice.message.content!,
+        });
+      }
+    });
+    return completion;
+  }
+  return nullableCompletion;
+}
+
+export { reduceStreamingWithDispatch };

package/src/utils/MPSC.ts

@@ -7,13 +7,15 @@ export class MPSC<T> {
   public constructor() {
     this.queue = new AsyncQueue<T>();
     this.consumer = new ReadableStream<T>({
-      pull: async (controller) => {
-        const { value, done } = await this.queue.dequeue();
-        if (done === true) {
-          controller.close();
-          return;
+      start: async (controller) => {
+        while (true) {
+          const { value, done } = await this.queue.dequeue();
+          if (done === true) {
+            controller.close();
+            return;
+          }
+          controller.enqueue(value);
         }
-        controller.enqueue(value);
       },
     });
   }

package/src/utils/StreamUtil.ts

@@ -34,10 +34,10 @@ async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R,
   return acc as R;
 }
 
-function from<T>(value: T): ReadableStream<T> {
+function from<T>(...value: T[]): ReadableStream<T> {
   const stream = new ReadableStream<T>({
     start: (controller) => {
-      controller.enqueue(value);
+      value.forEach(v => controller.enqueue(v));
       controller.close();
     },
   });

package/src/utils/__retry.spec.ts

@@ -0,0 +1,198 @@
+import { __get_retry } from "./__retry";
+
+describe("__get_retry", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("success cases", () => {
+    it("should not retry when successful on first attempt", async () => {
+      const mockFn = vi.fn().mockResolvedValue("success");
+      const retryFn = __get_retry(3);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(1);
+      expect(mockFn).toHaveBeenCalledWith(undefined);
+    });
+
+    it("should call exactly 2 times when successful on second attempt", async () => {
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(new Error("First failure"))
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(3);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(2);
+      expect(mockFn).toHaveBeenNthCalledWith(1, undefined);
+      expect(mockFn).toHaveBeenNthCalledWith(2, new Error("First failure"));
+    });
+
+    it("should call limit times when successful on last attempt", async () => {
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(new Error("First failure"))
+        .mockRejectedValueOnce(new Error("Second failure"))
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(3);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(3);
+      expect(mockFn).toHaveBeenNthCalledWith(1, undefined);
+      expect(mockFn).toHaveBeenNthCalledWith(2, new Error("First failure"));
+      expect(mockFn).toHaveBeenNthCalledWith(3, new Error("Second failure"));
+    });
+  });
+
+  describe("failure cases", () => {
+    it("should throw last error after limit attempts", async () => {
+      const error1 = new Error("First failure");
+      const error2 = new Error("Second failure");
+      const error3 = new Error("Third failure");
+
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(error1)
+        .mockRejectedValueOnce(error2)
+        .mockRejectedValueOnce(error3);
+      const retryFn = __get_retry(3);
+
+      await expect(retryFn(mockFn)).rejects.toThrow("Third failure");
+      expect(mockFn).toHaveBeenCalledTimes(3);
+      expect(mockFn).toHaveBeenNthCalledWith(1, undefined);
+      expect(mockFn).toHaveBeenNthCalledWith(2, error1);
+      expect(mockFn).toHaveBeenNthCalledWith(3, error2);
+    });
+
+    it("should throw error immediately when limit is 1", async () => {
+      const error = new Error("Immediate failure");
+      const mockFn = vi.fn().mockRejectedValue(error);
+      const retryFn = __get_retry(1);
+
+      await expect(retryFn(mockFn)).rejects.toThrow("Immediate failure");
+      expect(mockFn).toHaveBeenCalledTimes(1);
+      expect(mockFn).toHaveBeenCalledWith(undefined);
+    });
+  });
+
+  describe("prevError propagation", () => {
+    it("should pass previous error as prevError correctly", async () => {
+      const error1 = new Error("First error");
+      const error2 = new Error("Second error");
+
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(error1)
+        .mockRejectedValueOnce(error2)
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(3);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(3);
+      expect(mockFn).toHaveBeenNthCalledWith(1, undefined);
+      expect(mockFn).toHaveBeenNthCalledWith(2, error1);
+      expect(mockFn).toHaveBeenNthCalledWith(3, error2);
+    });
+
+    it("should use initial prevError in first call when provided", async () => {
+      const initialError = new Error("Initial error");
+      const mockFn = vi.fn().mockResolvedValue("success");
+      const retryFn = __get_retry(3);
+
+      const result = await retryFn(mockFn, initialError);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(1);
+      expect(mockFn).toHaveBeenCalledWith(initialError);
+    });
+  });
+
+  describe("different error types", () => {
+    it("should handle string errors correctly", async () => {
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce("String error")
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(2);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(2);
+      expect(mockFn).toHaveBeenNthCalledWith(2, "String error");
+    });
+
+    it("should handle null errors correctly", async () => {
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(null)
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(2);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(2);
+      expect(mockFn).toHaveBeenNthCalledWith(2, null);
+    });
+
+    it("should handle undefined errors correctly", async () => {
+      const mockFn = vi.fn()
+        .mockRejectedValueOnce(undefined)
+        .mockResolvedValue("success");
+      const retryFn = __get_retry(2);
+
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(mockFn).toHaveBeenCalledTimes(2);
+      expect(mockFn).toHaveBeenNthCalledWith(2, undefined);
+    });
+  });
+
+  describe("recursive call verification", () => {
+    it("should occur recursive calls in correct order", async () => {
+      const callOrder: string[] = [];
+      const mockFn = vi.fn()
+        .mockImplementationOnce(() => {
+          callOrder.push("first call");
+          throw new Error("First failure");
+        })
+        .mockImplementationOnce(() => {
+          callOrder.push("second call");
+          throw new Error("Second failure");
+        })
+        .mockImplementationOnce(async () => {
+          callOrder.push("third call");
+          return Promise.resolve("success");
+        });
+
+      const retryFn = __get_retry(3);
+      const result = await retryFn(mockFn);
+
+      expect(result).toBe("success");
+      expect(callOrder).toEqual(["first call", "second call", "third call"]);
+      expect(mockFn).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe("type safety", () => {
+    it("should handle different return types correctly", async () => {
+      const stringFn = vi.fn().mockResolvedValue("string result");
+      const numberFn = vi.fn().mockResolvedValue(42);
+      const objectFn = vi.fn().mockResolvedValue({ key: "value" });
+
+      const retryFn = __get_retry(3);
+
+      const stringResult = await retryFn(stringFn);
+      const numberResult = await retryFn(numberFn);
+      const objectResult = await retryFn(objectFn);
+
+      expect(stringResult).toBe("string result");
+      expect(numberResult).toBe(42);
+      expect(objectResult).toEqual({ key: "value" });
+    });
+  });
+});

package/src/utils/__retry.ts

@@ -0,0 +1,18 @@
+/**
+ * @internal
+ */
+export function __get_retry(limit: number) {
+  const retryFn = async <T>(fn: (prevError?: unknown) => Promise<T>, prevError?: unknown, attempt: number = 0): Promise<T> => {
+    try {
+      return await fn(prevError);
+    }
+    catch (error) {
+      if (attempt >= limit - 1) {
+        throw error;
+      }
+      return retryFn(fn, error, attempt + 1);
+    }
+  };
+
+  return retryFn;
+}