@agentica/core 0.10.3 → 0.11.0

package/src/chatgpt/ChatGptCancelFunctionAgent.ts

@@ -1,37 +1,34 @@
-import {
-  IHttpLlmFunction,
-  ILlmApplication,
-  ILlmSchema,
-} from "@samchon/openapi";
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 import typia, { IValidation } from "typia";
 import { v4 } from "uuid";
 
+import { AgenticaCancelPrompt } from "../context/AgenticaCancelPrompt";
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaOperation } from "../context/AgenticaOperation";
+import { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
+import { __IChatCancelFunctionsApplication } from "../context/internal/__IChatCancelFunctionsApplication";
+import { __IChatFunctionReference } from "../context/internal/__IChatFunctionReference";
+import { AgenticaCancelEvent } from "../events/AgenticaCancelEvent";
+import { AgenticaEvent } from "../events/AgenticaEvent";
 import { AgenticaConstant } from "../internal/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
-import { AgenticaPromptFactory } from "../internal/AgenticaPromptFactory";
 import { AgenticaSystemPrompt } from "../internal/AgenticaSystemPrompt";
-import { IAgenticaContext } from "../structures/IAgenticaContext";
-import { IAgenticaController } from "../structures/IAgenticaController";
-import { IAgenticaEvent } from "../structures/IAgenticaEvent";
-import { IAgenticaOperation } from "../structures/IAgenticaOperation";
-import { IAgenticaOperationSelection } from "../structures/IAgenticaOperationSelection";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
-import { __IChatCancelFunctionsApplication } from "../structures/internal/__IChatCancelFunctionsApplication";
-import { __IChatFunctionReference } from "../structures/internal/__IChatFunctionReference";
+import { StreamUtil } from "../internal/StreamUtil";
+import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptCancelFunctionAgent {
   export const execute = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-  ): Promise<IAgenticaPrompt.ICancel<Model>[]> => {
+    ctx: AgenticaContext<Model>,
+  ): Promise<AgenticaCancelPrompt<Model>[]> => {
     if (ctx.operations.divided === undefined)
       return step(ctx, ctx.operations.array, 0);
 
-    const stacks: IAgenticaOperationSelection<Model>[][] =
+    const stacks: AgenticaOperationSelection<Model>[][] =
       ctx.operations.divided.map(() => []);
-    const events: IAgenticaEvent<Model>[] = [];
-    const prompts: IAgenticaPrompt.ICancel<Model>[][] = await Promise.all(
+    const events: AgenticaEvent<Model>[] = [];
+    const prompts: AgenticaCancelPrompt<Model>[][] = await Promise.all(
       ctx.operations.divided.map((operations, i) =>
         step(
           {
@@ -58,67 +55,60 @@ export namespace ChatGptCancelFunctionAgent {
           .map(
             (s) =>
               ctx.operations.group
-                .get(s.controller.name)!
-                .get(s.function.name)!,
+                .get(s.operation.controller.name)!
+                .get(s.operation.function.name)!,
           ),
         0,
       );
 
     // RE-COLLECT SELECT FUNCTION EVENTS
-    const collection: IAgenticaPrompt.ICancel<Model> = {
+    const collection: AgenticaCancelPrompt<Model> = new AgenticaCancelPrompt({
       id: v4(),
-      type: "cancel",
-      operations: [],
-    };
+      selections: [],
+    });
     for (const e of events)
       if (e.type === "select") {
-        collection.operations.push(
-          AgenticaPromptFactory.selection({
-            protocol: e.operation.protocol as "http",
-            controller: e.operation
-              .controller as IAgenticaController.IHttp<Model>,
-            function: e.operation.function as IHttpLlmFunction<Model>,
-            reason: e.reason,
-            name: e.operation.name,
-          }),
-        );
+        collection.selections.push(e.selection);
         await cancelFunction(ctx, {
-          name: e.operation.name,
-          reason: e.reason,
+          name: e.selection.operation.name,
+          reason: e.selection.reason,
         });
       }
     return [collection];
   };
 
   export const cancelFunction = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
+    ctx: AgenticaContext<Model>,
     reference: __IChatFunctionReference,
-  ): Promise<IAgenticaOperationSelection<Model> | null> => {
+  ): Promise<AgenticaOperationSelection<Model> | null> => {
     const index: number = ctx.stack.findIndex(
-      (item) => item.name === reference.name,
+      (item) => item.operation.name === reference.name,
     );
     if (index === -1) return null;
 
-    const item: IAgenticaOperationSelection<Model> = ctx.stack[index]!;
+    const item: AgenticaOperationSelection<Model> = ctx.stack[index]!;
     ctx.stack.splice(index, 1);
-    await ctx.dispatch({
-      type: "cancel",
-      operation: item,
-      reason: reference.reason,
-    });
+    await ctx.dispatch(
+      new AgenticaCancelEvent({
+        selection: new AgenticaOperationSelection({
+          operation: item.operation,
+          reason: reference.reason,
+        }),
+      }),
+    );
     return item;
   };
 
   const step = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-    operations: IAgenticaOperation<Model>[],
+    ctx: AgenticaContext<Model>,
+    operations: AgenticaOperation<Model>[],
     retry: number,
     failures?: IFailure[],
-  ): Promise<IAgenticaPrompt.ICancel<Model>[]> => {
+  ): Promise<AgenticaCancelPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
-    const completion: OpenAI.ChatCompletion = await ctx.request("cancel", {
+    const completionStream = await ctx.request("cancel", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -189,6 +179,9 @@ export namespace ChatGptCancelFunctionAgent {
       parallel_tool_calls: true,
     });
 
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+
     //----
     // VALIDATION
     //----
@@ -213,7 +206,7 @@ export namespace ChatGptCancelFunctionAgent {
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt.ICancel<Model>[] = [];
+    const prompts: AgenticaCancelPrompt<Model>[] = [];
     for (const choice of completion.choices) {
       // TOOL CALLING HANDLER
       if (choice.message.tool_calls)
@@ -224,16 +217,16 @@ export namespace ChatGptCancelFunctionAgent {
           );
           if (typia.is(input) === false) continue;
           else if (tc.function.name === "cancelFunctions") {
-            const collection: IAgenticaPrompt.ICancel<Model> = {
-              id: tc.id,
-              type: "cancel",
-              operations: [],
-            };
+            const collection: AgenticaCancelPrompt<Model> =
+              new AgenticaCancelPrompt({
+                id: tc.id,
+                selections: [],
+              });
             for (const reference of input.functions) {
               const operation = await cancelFunction(ctx, reference);
-              if (operation !== null) collection.operations.push(operation);
+              if (operation !== null) collection.selections.push(operation);
             }
-            if (collection.operations.length !== 0) prompts.push(collection);
+            if (collection.selections.length !== 0) prompts.push(collection);
           }
         }
     }

package/src/chatgpt/ChatGptCompletionMessageUtil.ts

@@ -0,0 +1,166 @@
+import {
+  ChatCompletion,
+  ChatCompletionChunk,
+  ChatCompletionMessage,
+  ChatCompletionMessageToolCall,
+} from "openai/resources";
+import { json } from "typia";
+
+import { ByteArrayUtil } from "../internal/ByteArrayUtil";
+import { ChatGptUsageAggregator } from "./ChatGptUsageAggregator";
+
+export namespace ChatGptCompletionMessageUtil {
+  export const transformCompletionChunk = (
+    source: string | Uint8Array,
+  ): ChatCompletionChunk => {
+    const str =
+      source instanceof Uint8Array ? ByteArrayUtil.toUtf8(source) : source;
+    return json.assertParse<ChatCompletionChunk>(str);
+  };
+
+  export const accumulate = (
+    origin: ChatCompletion,
+    chunk: ChatCompletionChunk,
+  ): ChatCompletion => {
+    const choices = origin.choices;
+    chunk.choices.forEach((choice) => {
+      const accChoice = choices[choice.index];
+      if (accChoice) {
+        choices[choice.index] = mergeChoice(accChoice, choice);
+        return;
+      }
+
+      choices[choice.index] = {
+        index: choice.index,
+
+        finish_reason:
+          choice.finish_reason ??
+          (null as unknown as ChatCompletion.Choice["finish_reason"]),
+
+        logprobs: choice.logprobs ?? null,
+        message: {
+          tool_calls: choice.delta.tool_calls
+            ? choice.delta.tool_calls.reduce((acc, cur) => {
+                acc[cur.index] = {
+                  id: cur.id ?? "",
+                  type: "function",
+                  function: {
+                    name: cur.function?.name ?? "",
+                    arguments: cur.function?.arguments ?? "",
+                  },
+                };
+                return acc;
+              }, [] as ChatCompletionMessageToolCall[])
+            : undefined,
+          content: choice.delta.content ?? null,
+          refusal: choice.delta.refusal ?? null,
+          role: "assistant",
+        } satisfies ChatCompletionMessage,
+      };
+    });
+
+    const usage = (() => {
+      if (!chunk.usage) {
+        return origin.usage;
+      }
+
+      if (!origin.usage) {
+        return chunk.usage;
+      }
+
+      return ChatGptUsageAggregator.sum(origin.usage, chunk.usage);
+    })();
+
+    return {
+      ...origin,
+      choices,
+      usage,
+    };
+  };
+
+  export const merge = (chunks: ChatCompletionChunk[]): ChatCompletion => {
+    const firstChunk = chunks[0];
+    if (!firstChunk) throw new Error("No chunks received");
+
+    return chunks.reduce(ChatGptCompletionMessageUtil.accumulate, {
+      id: firstChunk.id,
+      choices: [],
+      created: firstChunk.created,
+      model: firstChunk.model,
+      object: "chat.completion",
+      usage: undefined,
+      service_tier: firstChunk.service_tier,
+      system_fingerprint: firstChunk.system_fingerprint,
+    } as ChatCompletion);
+  };
+
+  export const mergeChoice = (
+    acc: ChatCompletion.Choice,
+    cur: ChatCompletionChunk.Choice,
+  ): ChatCompletion.Choice => {
+    if (!acc.finish_reason && cur.finish_reason) {
+      acc.finish_reason = cur.finish_reason;
+    }
+
+    if (!acc.logprobs && cur.logprobs) {
+      acc.logprobs = cur.logprobs;
+    }
+
+    if (cur.delta.content) {
+      if (!acc.message.content) {
+        acc.message.content = cur.delta.content;
+      } else {
+        acc.message.content += cur.delta.content;
+      }
+    }
+
+    if (cur.delta.refusal) {
+      if (!acc.message.refusal) {
+        acc.message.refusal = cur.delta.refusal;
+      } else {
+        acc.message.refusal += cur.delta.refusal;
+      }
+    }
+
+    if (cur.delta.tool_calls) {
+      acc.message.tool_calls ??= [];
+      const toolCalls = acc.message.tool_calls;
+
+      cur.delta.tool_calls.forEach((toolCall) => {
+        const existingToolCall = toolCalls[toolCall.index];
+        if (existingToolCall) {
+          toolCalls[toolCall.index] = mergeToolCalls(
+            existingToolCall,
+            toolCall,
+          );
+          return;
+        }
+
+        toolCalls[toolCall.index] = {
+          id: toolCall.id ?? "",
+          type: "function",
+          function: {
+            name: toolCall.function?.name ?? "",
+            arguments: toolCall.function?.arguments ?? "",
+          },
+        };
+      });
+    }
+
+    return acc;
+  };
+
+  export const mergeToolCalls = (
+    acc: ChatCompletionMessageToolCall,
+    cur: ChatCompletionChunk.Choice.Delta.ToolCall,
+  ): ChatCompletionMessageToolCall => {
+    if (cur.function) {
+      acc.function.arguments += cur.function.arguments ?? "";
+      acc.function.name += cur.function.name ?? "";
+    }
+
+    acc.id += cur.id ?? "";
+
+    return acc;
+  };
+}

package/src/chatgpt/ChatGptDescribeFunctionAgent.ts

@@ -1,19 +1,24 @@
 import { ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaDescribeEvent } from "../events/AgenticaDescribeEvent";
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../internal/AgenticaSystemPrompt";
-import { IAgenticaContext } from "../structures/IAgenticaContext";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
+import { MPSCUtil } from "../internal/MPSCUtil";
+import { StreamUtil } from "../internal/StreamUtil";
+import { AgenticaDescribePrompt } from "../prompts/AgenticaDescribePrompt";
+import { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
+import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptDescribeFunctionAgent {
   export const execute = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-    histories: IAgenticaPrompt.IExecute<Model>[],
-  ): Promise<IAgenticaPrompt.IDescribe<Model>[]> => {
+    ctx: AgenticaContext<Model>,
+    histories: AgenticaExecutePrompt<Model>[],
+  ): Promise<AgenticaDescribePrompt<Model>[]> => {
     if (histories.length === 0) return [];
-    const completion: OpenAI.ChatCompletion = await ctx.request("describe", {
+    const completionStream = await ctx.request("describe", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -31,7 +36,73 @@ export namespace ChatGptDescribeFunctionAgent {
         },
       ],
     });
-    const descriptions: IAgenticaPrompt.IDescribe<Model>[] = completion.choices
+
+    const describeContext: ({
+      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) {
+            describeContext[choice.index]!.close();
+            continue;
+          }
+          if (!choice.delta.content) {
+            continue;
+          }
+
+          if (describeContext[choice.index]) {
+            describeContext[choice.index]!.content += choice.delta.content;
+            describeContext[choice.index]!.produce(choice.delta.content);
+            continue;
+          }
+
+          const { consumer, produce, close, waitClose, done } =
+            MPSCUtil.create<string>();
+
+          describeContext[choice.index] = {
+            content: choice.delta.content,
+            consumer,
+            produce,
+            close,
+            waitClose,
+            done,
+          };
+          produce(choice.delta.content);
+
+          void ctx.dispatch(
+            new AgenticaDescribeEvent({
+              executes: histories,
+              stream: consumer,
+              done,
+              get: () => describeContext[choice.index]?.content ?? "",
+              join: async () => {
+                await waitClose();
+                return describeContext[choice.index]!.content;
+              },
+            }),
+          );
+        }
+      };
+
+      if (acc.object === "chat.completion.chunk") {
+        registerContext([acc, chunk].flatMap((acc) => acc.choices));
+        return ChatGptCompletionMessageUtil.merge([acc, chunk]);
+      }
+
+      registerContext(chunk.choices);
+      return ChatGptCompletionMessageUtil.accumulate(acc, chunk);
+    });
+
+    if (!completion) throw new Error("No completion received");
+    const descriptions: AgenticaDescribePrompt<Model>[] = completion.choices
       .map((choice) =>
         choice.message.role === "assistant" && !!choice.message.content?.length
           ? choice.message.content
@@ -40,13 +111,11 @@ export namespace ChatGptDescribeFunctionAgent {
       .filter((str) => str !== null)
       .map(
         (content) =>
-          ({
-            type: "describe",
-            executions: histories,
+          new AgenticaDescribePrompt({
+            executes: histories,
             text: content,
-          }) satisfies IAgenticaPrompt.IDescribe<Model>,
+          }),
       );
-    for (const describe of descriptions) await ctx.dispatch(describe);
     return descriptions;
   };
 }

package/src/chatgpt/ChatGptHistoryDecoder.ts

@@ -1,11 +1,11 @@
 import { ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
+import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
 
 export namespace ChatGptHistoryDecoder {
   export const decode = <Model extends ILlmSchema.Model>(
-    history: IAgenticaPrompt<Model>,
+    history: AgenticaPrompt<Model>,
   ): OpenAI.ChatCompletionMessageParam[] => {
     // NO NEED TO DECODE DESCRIBE
     if (history.type === "describe") return [];
@@ -27,9 +27,9 @@ export namespace ChatGptHistoryDecoder {
               function: {
                 name: `${history.type}Functions`,
                 arguments: JSON.stringify({
-                  functions: history.operations.map((t) => ({
-                    name: t.function.name,
-                    reason: t.reason,
+                  functions: history.selections.map((s) => ({
+                    name: s.operation.function.name,
+                    reason: s.reason,
                   })),
                 }),
               },
@@ -51,7 +51,7 @@ export namespace ChatGptHistoryDecoder {
             type: "function",
             id: history.id,
             function: {
-              name: history.function.name,
+              name: history.operation.name,
               arguments: JSON.stringify(history.arguments),
             },
           },
@@ -62,18 +62,18 @@ export namespace ChatGptHistoryDecoder {
         tool_call_id: history.id,
         content: JSON.stringify({
           function: {
-            protocol: history.protocol,
-            description: history.function.description,
-            parameters: history.function.parameters,
-            output: history.function.output,
-            ...(history.protocol === "http"
+            protocol: history.operation.protocol,
+            description: history.operation.function.description,
+            parameters: history.operation.function.parameters,
+            output: history.operation.function.output,
+            ...(history.operation.protocol === "http"
               ? {
-                  method: history.function.method,
-                  path: history.function.path,
+                  method: history.operation.function.method,
+                  path: history.operation.function.path,
                 }
               : {}),
           },
-          ...(history.protocol === "http"
+          ...(history.operation.protocol === "http"
             ? {
                 status: history.value.status,
                 data: history.value.body,

package/src/chatgpt/ChatGptInitializeFunctionAgent.ts

@@ -2,21 +2,24 @@ import { ILlmFunction, ILlmSchema } from "@samchon/openapi";
 import OpenAI from "openai";
 import typia from "typia";
 
+import { AgenticaContext } from "../context/AgenticaContext";
+import { __IChatInitialApplication } from "../context/internal/__IChatInitialApplication";
 import { AgenticaDefaultPrompt } from "../internal/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../internal/AgenticaSystemPrompt";
-import { IAgenticaContext } from "../structures/IAgenticaContext";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
-import { __IChatInitialApplication } from "../structures/internal/__IChatInitialApplication";
+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: IAgenticaContext<Model>,
-  ): Promise<IAgenticaPrompt<Model>[]> => {
+    ctx: AgenticaContext<Model>,
+  ): Promise<AgenticaPrompt<Model>[]> => {
     //----
     // EXECUTE CHATGPT API
     //----
-    const completion: OpenAI.ChatCompletion = await ctx.request("initialize", {
+    const completionStream = await ctx.request("initialize", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -53,20 +56,25 @@ export namespace ChatGptInitializeFunctionAgent {
       parallel_tool_calls: false,
     });
 
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
     //----
     // PROCESS COMPLETION
     //----
-    const prompts: IAgenticaPrompt<Model>[] = [];
+    const prompts: AgenticaPrompt<Model>[] = [];
     for (const choice of completion.choices) {
       if (
         choice.message.role === "assistant" &&
         !!choice.message.content?.length
-      )
-        prompts.push({
-          type: "text",
-          role: "assistant",
-          text: choice.message.content,
-        });
+      ) {
+        // @TODO this logic should call the dispatch function
+        prompts.push(
+          new AgenticaTextPrompt({
+            role: "assistant",
+            text: choice.message.content,
+          }),
+        );
+      }
     }
     if (
       completion.choices.some(