@agentica/core 0.32.9 → 0.33.0

package/src/utils/ChatGptCompletionStreamingUtil.ts

@@ -23,7 +23,8 @@ async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletion
             const context = streamContext.get(choice.index)!;
             context.content += choice.delta.content;
             context.mpsc.produce(choice.delta.content);
-          } else {
+          }
+          else {
             const mpsc = new MPSC<string>();
 
             streamContext.set(choice.index, {
@@ -43,7 +44,7 @@ async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletion
             });
           }
         }
-        
+
         // Handle finish_reason after content processing
         if (choice.finish_reason != null) {
           const context = streamContext.get(choice.index);
@@ -70,10 +71,10 @@ async function reduceStreamingWithDispatch(stream: ReadableStream<ChatCompletion
     );
   }
 
-  if((nullableCompletion.object as string) === "chat.completion.chunk") {
+  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 !== "") {
+      if (choice.message.content != null && choice.message.content !== "") {
         eventProcessor({
           stream: toAsyncGenerator(choice.message.content),
           done: () => true,

package/src/utils/JsonUtil.spec.ts

@@ -1,185 +1,184 @@
 import { JsonUtil } from "./JsonUtil";
 
-describe("JsonUtil", () => {
+describe("jsonUtil", () => {
   describe("parse", () => {
-    
-    describe("Normal Operations", () => {
+    describe("normal Operations", () => {
       it("should parse standard valid JSON", () => {
-        const jsonString = '{"normal": "json"}';
+        const jsonString = "{\"normal\": \"json\"}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ normal: "json" });
       });
 
       it("should handle object with '{}' prefix", () => {
-        const jsonString = '{}{"name": "test", "value": 42}';
+        const jsonString = "{}{\"name\": \"test\", \"value\": 42}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ name: "test", value: 42 });
       });
 
       it("should handle array with '{}' prefix", () => {
-        const jsonString = '{}[1, 2, 3, "test"]';
+        const jsonString = "{}[1, 2, 3, \"test\"]";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual([1, 2, 3, "test"]);
       });
 
       it("should handle primitive values with '{}' prefix", () => {
-        expect(JsonUtil.parse('{}42')).toBe(42);
-        expect(JsonUtil.parse('{}"hello"')).toBe("hello");
-        expect(JsonUtil.parse('{}true')).toBe(true);
-        expect(JsonUtil.parse('{}null')).toBeNull();
+        expect(JsonUtil.parse("{}42")).toBe(42);
+        expect(JsonUtil.parse("{}\"hello\"")).toBe("hello");
+        expect(JsonUtil.parse("{}true")).toBe(true);
+        expect(JsonUtil.parse("{}null")).toBeNull();
       });
 
       it("should remove trailing comma in object", () => {
-        const jsonString = '{"name": "test", "value": 42,}';
+        const jsonString = "{\"name\": \"test\", \"value\": 42,}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ name: "test", value: 42 });
       });
 
       it("should remove trailing comma in array", () => {
-        const jsonString = '[1, 2, 3, "test",]';
+        const jsonString = "[1, 2, 3, \"test\",]";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual([1, 2, 3, "test"]);
       });
 
       it("should add missing closing brace in object", () => {
-        const jsonString = '{"name": "test", "value": 42';
+        const jsonString = "{\"name\": \"test\", \"value\": 42";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ name: "test", value: 42 });
       });
 
       it("should add missing closing bracket in array", () => {
-        const jsonString = '[1, 2, 3, "test"';
+        const jsonString = "[1, 2, 3, \"test\"";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual([1, 2, 3, "test"]);
       });
     });
 
-    describe("Combined Features", () => {
+    describe("combined Features", () => {
       it("should handle '{}' prefix and missing closing brace together", () => {
-        const jsonString = '{}{"name": "test", "value": 42';
+        const jsonString = "{}{\"name\": \"test\", \"value\": 42";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ name: "test", value: 42 });
       });
 
       it("should handle '{}' prefix and missing closing bracket together", () => {
-        const jsonString = '{}[1, 2, 3, "test"';
+        const jsonString = "{}[1, 2, 3, \"test\"";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual([1, 2, 3, "test"]);
       });
 
       it("should handle trailing comma in nested objects", () => {
-        const jsonString = '{"user": {"id": 1, "name": "John",}, "active": true,}';
+        const jsonString = "{\"user\": {\"id\": 1, \"name\": \"John\",}, \"active\": true,}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
           user: { id: 1, name: "John" },
-          active: true
+          active: true,
         });
       });
 
       it("should handle missing closing brace in nested objects", () => {
-        const jsonString = '{"user": {"id": 1, "name": "John"}';
+        const jsonString = "{\"user\": {\"id\": 1, \"name\": \"John\"}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
-          user: { id: 1, name: "John" }
+          user: { id: 1, name: "John" },
         });
       });
 
       it("should handle missing closing brace in complex nested structure", () => {
-        const jsonString = '{"users": [{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}], "count": 2';
+        const jsonString = "{\"users\": [{\"id\": 1, \"name\": \"John\"}, {\"id\": 2, \"name\": \"Jane\"}], \"count\": 2";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
           users: [
             { id: 1, name: "John" },
-            { id: 2, name: "Jane" }
+            { id: 2, name: "Jane" },
           ],
-          count: 2
+          count: 2,
         });
       });
 
       it("should apply all correction features together", () => {
-        const jsonString = '{}{"name": "test", "items": [1, 2, 3,], "user": {"id": 1, "name": "John",}';
+        const jsonString = "{}{\"name\": \"test\", \"items\": [1, 2, 3,], \"user\": {\"id\": 1, \"name\": \"John\",}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
           name: "test",
           items: [1, 2, 3],
-          user: { id: 1, name: "John" }
+          user: { id: 1, name: "John" },
         });
       });
 
       it("should handle all issues simultaneously in complex nested structure", () => {
-        const jsonString = '{}{"data": {"users": [{"id": 1, "name": "John",}, {"id": 2, "name": "Jane",}], "meta": {"total": 2, "page": 1,}}, "status": "ok",';
+        const jsonString = "{}{\"data\": {\"users\": [{\"id\": 1, \"name\": \"John\",}, {\"id\": 2, \"name\": \"Jane\",}], \"meta\": {\"total\": 2, \"page\": 1,}}, \"status\": \"ok\",";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
           data: {
             users: [
               { id: 1, name: "John" },
-              { id: 2, name: "Jane" }
+              { id: 2, name: "Jane" },
             ],
-            meta: { total: 2, page: 1 }
+            meta: { total: 2, page: 1 },
           },
-          status: "ok"
+          status: "ok",
         });
       });
     });
 
-    describe("Edge Cases", () => {
+    describe("edge Cases", () => {
       it("should handle empty object with '{}' prefix", () => {
-        const jsonString = '{}{}';
+        const jsonString = "{}{}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({});
       });
 
       it("should handle empty array with '{}' prefix", () => {
-        const jsonString = '{}[]';
+        const jsonString = "{}[]";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual([]);
       });
 
       it("should handle nested object with '{}' prefix", () => {
-        const jsonString = '{}{"user": {"id": 1, "name": "John"}}';
+        const jsonString = "{}{\"user\": {\"id\": 1, \"name\": \"John\"}}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
-          user: { id: 1, name: "John" }
+          user: { id: 1, name: "John" },
         });
       });
 
       it("should handle multiple trailing commas", () => {
-        const jsonString = '{"items": [1, 2, 3,,,], "count": 3,,,}';
+        const jsonString = "{\"items\": [1, 2, 3,,,], \"count\": 3,,,}";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({
           items: [1, 2, 3],
-          count: 3
+          count: 3,
         });
       });
 
       it("should handle JSON with whitespace and formatting issues", () => {
-        const jsonString = '{} { "name" : "test" , "value" : 42 , } ';
+        const jsonString = "{} { \"name\" : \"test\" , \"value\" : 42 , } ";
         const result = JsonUtil.parse(jsonString);
-        
+
         expect(result).toEqual({ name: "test", value: 42 });
       });
 
       it("should throw error for completely invalid JSON", () => {
-        const invalidJson = '{invalid: json without quotes}';
-        
+        const invalidJson = "{invalid: json without quotes}";
+
         expect(() => JsonUtil.parse(invalidJson)).toThrow();
       });
 
@@ -187,6 +186,5 @@ describe("JsonUtil", () => {
         expect(() => JsonUtil.parse("")).toThrow();
       });
     });
-
   });
 });

package/src/utils/JsonUtil.ts

@@ -4,10 +4,8 @@ export const JsonUtil = {
   parse,
 };
 
+const pipe = (...fns: ((str: string) => string)[]) => (str: string) => fns.reduce((acc, fn) => fn(acc), str);
 function parse(str: string) {
   const corrected = pipe(removeEmptyObjectPrefix, addMissingBraces, removeTrailingCommas)(str);
   return JSON.parse(corrected);
 }
-
-const pipe = (...fns: ((str: string) => string)[]) => (str: string) => fns.reduce((acc, fn) => fn(acc), str);
-

package/src/utils/StreamUtil.spec.ts

@@ -149,7 +149,7 @@ describe("streamUtil", () => {
       const stringResult = await StreamUtil.reduce<number, string>(
         stringStream,
         (acc, cur) => acc + cur.toString(),
-        { initial: ""},
+        { initial: "" },
       );
 
       expect(stringResult).toBe("123");

package/src/utils/StreamUtil.ts

@@ -17,7 +17,7 @@ async function readAll<T>(stream: ReadableStream<T>, abortSignal?: AbortSignal):
   return result;
 }
 
-async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, options: { initial?: R, abortSignal?: AbortSignal }): Promise<R | null> {
+async function reduce<T, R = T>(stream: ReadableStream<T>, reducer: (acc: T | R, cur: T) => R, options: { initial?: R; abortSignal?: AbortSignal }): Promise<R | null> {
   const reader = stream.getReader();
   const iterator = streamDefaultReaderToAsyncGenerator(reader);
   let acc = (options.initial ?? null) as R | null | T;
@@ -73,7 +73,7 @@ function transform<T, R>(stream: ReadableStream<T>, transformer: (value: T) => R
         controller.close();
         return;
       }
-      
+
       controller.enqueue(transformer(value));
     },
   });

package/src/utils/request.ts

@@ -1,101 +1,108 @@
-import OpenAI from "openai";
-import { AgenticaEventSource, AgenticaRequestEvent, AgenticaResponseEvent } from "../events";
+import type { ILlmSchema } from "@samchon/openapi";
+import type OpenAI from "openai";
+
+import { v4 } from "uuid";
+
+import type { AgenticaTokenUsage } from "../context/AgenticaTokenUsage";
+import type { AgenticaEventSource, AgenticaRequestEvent, AgenticaResponseEvent } from "../events";
+import type { IAgenticaConfig, IAgenticaVendor, IMicroAgenticaConfig } from "../structures";
+
+import { AgenticaTokenUsageAggregator } from "../context/internal/AgenticaTokenUsageAggregator";
+import { createRequestEvent } from "../factory";
+
 import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { streamDefaultReaderToAsyncGenerator, StreamUtil } from "./StreamUtil";
-import { createRequestEvent } from "../factory";
-import { IAgenticaConfig, IAgenticaVendor, IMicroAgenticaConfig } from "../structures";
-import { ILlmSchema } from "@samchon/openapi";
-import { AgenticaTokenUsageAggregator } from "../context/internal/AgenticaTokenUsageAggregator";
-import { AgenticaTokenUsage } from "../context/AgenticaTokenUsage";
-import { v4 } from "uuid";
 
-export const getChatCompletionWithStreamingFunction = <Model extends ILlmSchema.Model>(props: {
+export function getChatCompletionWithStreamingFunction<Model extends ILlmSchema.Model>(props: {
   vendor: IAgenticaVendor;
   config?: IAgenticaConfig<Model> | IMicroAgenticaConfig<Model>;
   dispatch: (event: AgenticaRequestEvent | AgenticaResponseEvent) => Promise<void>;
   abortSignal?: AbortSignal;
   usage: AgenticaTokenUsage;
-}) => async (
-  source: AgenticaEventSource,
-  body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
-) => {
-  const event: AgenticaRequestEvent = createRequestEvent({
-    source,
-    body: {
-      ...body,
-      model: props.vendor.model,
-      stream: true,
-      stream_options: {
-        include_usage: true,
+}) {
+  return async (
+    source: AgenticaEventSource,
+    body: Omit<OpenAI.ChatCompletionCreateParamsStreaming, "model" | "stream">,
+  ) => {
+    const event: AgenticaRequestEvent = createRequestEvent({
+      source,
+      body: {
+        ...body,
+        model: props.vendor.model,
+        stream: true,
+        stream_options: {
+          include_usage: true,
+        },
+      },
+      options: {
+        ...props.vendor.options,
+        signal: props.abortSignal,
       },
-    },
-    options: {
-      ...props.vendor.options,
-      signal: props.abortSignal,
-    },
-  });
-  await props.dispatch(event);
+    });
+    await props.dispatch(event);
 
-  // completion
-  const backoffStrategy = props.config?.backoffStrategy ?? ((props) => {
-    throw props.error;
-  });
-  const completion = await (async () => {
-    let count = 0;
-    while (true) {
-      try {
-        return await props.vendor.api.chat.completions.create(
-          event.body,
-          event.options,
-        );
+    // completion
+    const backoffStrategy = props.config?.backoffStrategy ?? ((props) => {
+      throw props.error;
+    });
+    const completion = await (async () => {
+      let count = 0;
+      while (true) {
+        try {
+          return await props.vendor.api.chat.completions.create(
+            event.body,
+            event.options,
+          );
+        }
+        catch (error) {
+          const waiting = backoffStrategy({ count, error });
+          await new Promise(resolve => setTimeout(resolve, waiting));
+          count++;
+        }
       }
-      catch (error) {
-        const waiting = backoffStrategy({ count, error });
-        await new Promise(resolve => setTimeout(resolve, waiting));
-        count++;
-      }
-    }
-  })();
+    })();
 
-  const [streamForEvent, temporaryStream] = StreamUtil.transform(
-    completion.toReadableStream() as ReadableStream<Uint8Array>,
-    value =>
-      ChatGptCompletionMessageUtil.transformCompletionChunk(value),
-    props.abortSignal,
-  ).tee();
+    const [streamForEvent, temporaryStream] = StreamUtil.transform(
+      completion.toReadableStream() as ReadableStream<Uint8Array>,
+      value =>
+        ChatGptCompletionMessageUtil.transformCompletionChunk(value),
+      props.abortSignal,
+    ).tee();
 
-  const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+    const [streamForAggregate, streamForReturn] = temporaryStream.tee();
 
-  (async () => {
-    const reader = streamForAggregate.getReader();
-    while (true) {
-      const chunk = await reader.read();
-      if (chunk.done || props.abortSignal?.aborted === true) {
-        break;
-      }
-      if (chunk.value.usage != null) {
-        AgenticaTokenUsageAggregator.aggregate({
-          kind: source,
-          completionUsage: chunk.value.usage,
-          usage: props.usage,
-        });
+    (async () => {
+      const reader = streamForAggregate.getReader();
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done || props.abortSignal?.aborted === true) {
+          break;
+        }
+        if (chunk.value.usage != null) {
+          AgenticaTokenUsageAggregator.aggregate({
+            kind: source,
+            completionUsage: chunk.value.usage,
+            usage: props.usage,
+          });
+        }
       }
-    }
-  })().catch(() => {});
+    })().catch(() => {});
 
-  const [streamForStream, streamForJoin] = streamForEvent.tee();
-  void props.dispatch({
-    id: v4(),
-    type: "response",
-    source,
-    stream: streamDefaultReaderToAsyncGenerator(streamForStream.getReader(), props.abortSignal),
-    body: event.body,
-    options: event.options,
-    join: async () => {
-      const chunks = await StreamUtil.readAll(streamForJoin, props.abortSignal);
-      return ChatGptCompletionMessageUtil.merge(chunks);
-    },
-    created_at: new Date().toISOString(),
-  }).catch(() => {});
-  return streamForReturn;
-};
+    const [streamForStream, streamForJoin] = streamForEvent.tee();
+    void props.dispatch({
+      id: v4(),
+      type: "response",
+      request_id: event.id,
+      source,
+      stream: streamDefaultReaderToAsyncGenerator(streamForStream.getReader(), props.abortSignal),
+      body: event.body,
+      options: event.options,
+      join: async () => {
+        const chunks = await StreamUtil.readAll(streamForJoin, props.abortSignal);
+        return ChatGptCompletionMessageUtil.merge(chunks);
+      },
+      created_at: new Date().toISOString(),
+    }).catch(() => {});
+    return streamForReturn;
+  };
+}