@agentica/core 0.12.20 → 0.13.0

package/src/chatgpt/ChatGptInitializeFunctionAgent.ts

@@ -1,28 +1,30 @@
-import { ILlmFunction, ILlmSchema } from "@samchon/openapi";
-import OpenAI from "openai";
-import typia from "typia";
+import type { ILlmFunction, ILlmSchema } from "@samchon/openapi";
+import type OpenAI from "openai";
+import type { AgenticaContext } from "../context/AgenticaContext";
 
-import { AgenticaContext } from "../context/AgenticaContext";
-import { __IChatInitialApplication } from "../context/internal/__IChatInitialApplication";
+import type { __IChatInitialApplication } from "../context/internal/__IChatInitialApplication";
+import type { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import typia from "typia";
 import { AgenticaTextEvent } from "../events/AgenticaTextEvent";
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../internal/AgenticaSystemPrompt";
-import { MPSCUtil } from "../internal/MPSCUtil";
+import { MPSC } from "../internal/MPSC";
 import { StreamUtil } from "../internal/StreamUtil";
-import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
 import { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
 import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
-export namespace ChatGptInitializeFunctionAgent {
-  export const execute = async <Model extends ILlmSchema.Model>(
-    ctx: AgenticaContext<Model>,
-  ): Promise<AgenticaPrompt<Model>[]> => {
-    //----
-    // EXECUTE CHATGPT API
-    //----
-    const completionStream = await ctx.request("initialize", {
-      messages: [
+const FUNCTION: ILlmFunction<"chatgpt"> = typia.llm.application<
+  __IChatInitialApplication,
+  "chatgpt"
+>().functions[0]!;
+
+export async function execute<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<AgenticaPrompt<Model>[]> {
+  // ----
+  // EXECUTE CHATGPT API
+  // ----
+  const completionStream = await ctx.request("initialize", {
+    messages: [
         // COMMON SYSTEM PROMPT
         {
           role: "system",
@@ -39,126 +41,129 @@ export namespace ChatGptInitializeFunctionAgent {
           // SYSTEM PROMPT
           role: "system",
           content:
-            ctx.config?.systemPrompt?.initialize?.(ctx.histories) ??
-            AgenticaSystemPrompt.INITIALIZE,
+            ctx.config?.systemPrompt?.initialize?.(ctx.histories)
+            ?? AgenticaSystemPrompt.INITIALIZE,
         },
-      ],
-      // GETTER FUNCTION
-      tools: [
-        {
-          type: "function",
-          function: {
-            name: FUNCTION.name,
-            description: FUNCTION.description,
-            parameters: FUNCTION.parameters as any,
-          },
+    ],
+    // GETTER FUNCTION
+    tools: [
+      {
+        type: "function",
+        function: {
+          name: FUNCTION.name,
+          description: FUNCTION.description,
+          /**
+           * @TODO fix it
+           * The property and value have a type mismatch, but it works.
+           */
+          parameters: FUNCTION.parameters as unknown as Record<string, unknown>,
         },
-      ],
-      tool_choice: "auto",
-      parallel_tool_calls: false,
-    });
-
-    const textContext: ({
-      content: string;
-    } & ReturnType<typeof MPSCUtil.create<string>>)[] = [];
-
-    const completion = await StreamUtil.reduce<
-      OpenAI.ChatCompletionChunk,
-      Promise<OpenAI.ChatCompletion>
-    >(completionStream, async (accPromise, chunk) => {
-      const acc = await accPromise;
-      const registerContext = (
-        choices: OpenAI.ChatCompletionChunk.Choice[],
-      ) => {
-        for (const choice of choices) {
-          if (choice.finish_reason) {
-            textContext[choice.index]?.close();
-            continue;
-          }
-          if (!choice.delta.content) {
-            continue;
-          }
-
-          if (textContext[choice.index]) {
-            textContext[choice.index]!.content += choice.delta.content;
-            textContext[choice.index]!.produce(choice.delta.content);
-            continue;
-          }
-
-          const { consumer, produce, close, waitClosed, waitUntilEmpty, done } =
-            MPSCUtil.create<string>();
-
-          textContext[choice.index] = {
-            content: choice.delta.content,
-            consumer,
-            produce,
-            close,
-            waitClosed,
-            waitUntilEmpty,
-            done,
-          };
-          produce(choice.delta.content);
-
-          void ctx.dispatch(
-            new AgenticaTextEvent({
-              role: "assistant",
-              stream: consumer,
-              done,
-              get: () => textContext[choice.index]?.content ?? "",
-              join: async () => {
-                await waitClosed();
-                return textContext[choice.index]!.content;
-              },
-            }),
-          );
+      },
+    ],
+    tool_choice: "auto",
+    parallel_tool_calls: false,
+  });
+
+  const textContext: ({
+    content: string;
+    mpsc: MPSC<string>;
+  })[] = [];
+
+  const completion = await StreamUtil.reduce<
+    OpenAI.ChatCompletionChunk,
+    Promise<OpenAI.ChatCompletion>
+  >(completionStream, async (accPromise, chunk) => {
+    const acc = await accPromise;
+    const registerContext = (
+      choices: OpenAI.ChatCompletionChunk.Choice[],
+    ) => {
+      for (const choice of choices) {
+        /**
+         * @TODO fix it
+         * Sometimes, the complete message arrives along with a finish reason.
+         */
+        if (choice.finish_reason != null) {
+          textContext[choice.index]?.mpsc.close();
+          continue;
         }
-      };
 
-      if (acc.object === "chat.completion.chunk") {
-        registerContext([acc, chunk].flatMap((v) => v.choices));
-        return ChatGptCompletionMessageUtil.merge([acc, chunk]);
-      }
+        if (choice.delta.content == null) {
+          continue;
+        }
 
-      registerContext(chunk.choices);
-      return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
-    });
+        if (textContext[choice.index] != null) {
+          textContext[choice.index]!.content += choice.delta.content;
+          textContext[choice.index]!.mpsc.produce(choice.delta.content);
+          continue;
+        }
 
-    if (!completion) {
-      throw new Error("No completion received");
-    }
+        const mpsc = new MPSC<string>();
+
+        textContext[choice.index] = {
+          content: choice.delta.content,
+          mpsc,
+        };
+        mpsc.produce(choice.delta.content);
 
-    //----
-    // PROCESS COMPLETION
-    //----
-    const prompts: AgenticaPrompt<Model>[] = [];
-    for (const choice of completion.choices) {
-      if (
-        choice.message.role === "assistant" &&
-        !!choice.message.content?.length
-      ) {
-        prompts.push(
-          new AgenticaTextPrompt({
+        void ctx.dispatch(
+          new AgenticaTextEvent({
             role: "assistant",
-            text: choice.message.content,
+            stream: mpsc.consumer,
+            done: () => mpsc.done(),
+            get: () => textContext[choice.index]!.content,
+            join: async () => {
+              await mpsc.waitClosed();
+              return textContext[choice.index]!.content;
+            },
           }),
         );
       }
+    };
+
+    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 (completion === null) {
+    throw new Error("No completion received");
+  }
+
+  // ----
+  // PROCESS COMPLETION
+  // ----
+  const prompts: AgenticaPrompt<Model>[] = [];
+  for (const choice of completion.choices) {
     if (
-      completion.choices.some(
-        (c) =>
-          !!c.message.tool_calls?.some(
-            (tc) =>
-              tc.type === "function" && tc.function.name === FUNCTION.name,
-          ),
-      )
+      choice.message.role === "assistant"
+      && choice.message.content != null
+    ) {
+      prompts.push(
+        new AgenticaTextPrompt({
+          role: "assistant",
+          text: choice.message.content,
+        }),
+      );
+    }
+  }
+  if (
+    completion.choices.some(
+      c =>
+        c.message.tool_calls != null
+        && c.message.tool_calls.some(
+          tc =>
+            tc.type === "function" && tc.function.name === FUNCTION.name,
+        ),
     )
-      await ctx.initialize();
-    return prompts;
-  };
+  ) { await ctx.initialize(); }
+
+  return prompts;
 }
 
-const FUNCTION: ILlmFunction<"chatgpt"> = typia.llm.application<
-  __IChatInitialApplication,
-  "chatgpt"
->().functions[0]!;
+export const ChatGptInitializeFunctionAgent = {
+  execute,
+};