@agentica/core 0.10.4 → 0.11.1

package/src/Agentica.ts

@@ -1,22 +1,27 @@
 import { ILlmSchema } from "@samchon/openapi";
-import OpenAI from "openai";
 
 import { ChatGptAgent } from "./chatgpt/ChatGptAgent";
+import { ChatGptCompletionMessageUtil } from "./chatgpt/ChatGptCompletionMessageUtil";
+import { AgenticaContext } from "./context/AgenticaContext";
+import { AgenticaOperation } from "./context/AgenticaOperation";
+import { AgenticaOperationCollection } from "./context/AgenticaOperationCollection";
+import { AgenticaOperationSelection } from "./context/AgenticaOperationSelection";
+import { AgenticaTokenUsage } from "./context/AgenticaTokenUsage";
+import { AgenticaTokenUsageAggregator } from "./context/internal/AgenticaTokenUsageAggregator";
+import { AgenticaEvent } from "./events/AgenticaEvent";
+import { AgenticaInitializeEvent } from "./events/AgenticaInitializeEvent";
+import { AgenticaRequestEvent } from "./events/AgenticaRequestEvent";
+import { AgenticaTextEvent } from "./events/AgenticaTextEvent";
 import { AgenticaOperationComposer } from "./internal/AgenticaOperationComposer";
-import { AgenticaPromptTransformer } from "./internal/AgenticaPromptTransformer";
-import { AgenticaTokenUsageAggregator } from "./internal/AgenticaTokenUsageAggregator";
+import { StreamUtil } from "./internal/StreamUtil";
 import { __map_take } from "./internal/__map_take";
+import { AgenticaPrompt } from "./prompts/AgenticaPrompt";
+import { AgenticaTextPrompt } from "./prompts/AgenticaTextPrompt";
 import { IAgenticaConfig } from "./structures/IAgenticaConfig";
-import { IAgenticaContext } from "./structures/IAgenticaContext";
 import { IAgenticaController } from "./structures/IAgenticaController";
-import { IAgenticaEvent } from "./structures/IAgenticaEvent";
-import { IAgenticaOperation } from "./structures/IAgenticaOperation";
-import { IAgenticaOperationCollection } from "./structures/IAgenticaOperationCollection";
-import { IAgenticaOperationSelection } from "./structures/IAgenticaOperationSelection";
-import { IAgenticaPrompt } from "./structures/IAgenticaPrompt";
 import { IAgenticaProps } from "./structures/IAgenticaProps";
-import { IAgenticaTokenUsage } from "./structures/IAgenticaTokenUsage";
 import { IAgenticaVendor } from "./structures/IAgenticaVendor";
+import { AgenticaPromptTransformer } from "./transformers/AgenticaPromptTransformer";
 
 /**
  * Nestia A.I. chatbot agent.
@@ -39,27 +44,27 @@ import { IAgenticaVendor } from "./structures/IAgenticaVendor";
  *   - {@link IAgenticaSystemPrompt}
  * - Accessors
  *   - {@link IAgenticaOperation}
- *   - {@link IAgenticaPrompt}
- *   - {@link IAgenticaEvent}
- *   - {@link IAgenticaTokenUsage}
+ *   - {@link IAgenticaPromptJson}
+ *   - {@link IAgenticaEventJson}
+ *   - {@link IAgenticaTokenUsageJson}
  *
  * @author Samchon
  */
 export class Agentica<Model extends ILlmSchema.Model> {
   // THE OPERATIONS
-  private readonly operations_: IAgenticaOperationCollection<Model>;
+  private readonly operations_: AgenticaOperationCollection<Model>;
 
   // STACK
-  private readonly stack_: IAgenticaOperationSelection<Model>[];
-  private readonly prompt_histories_: IAgenticaPrompt<Model>[];
+  private readonly stack_: AgenticaOperationSelection<Model>[];
+  private readonly prompt_histories_: AgenticaPrompt<Model>[];
   private readonly listeners_: Map<string, Set<Function>>;
 
   // STATUS
-  private readonly token_usage_: IAgenticaTokenUsage;
+  private readonly token_usage_: AgenticaTokenUsage;
   private ready_: boolean;
   private readonly executor_: (
-    ctx: IAgenticaContext<Model>,
-  ) => Promise<IAgenticaPrompt<Model>[]>;
+    ctx: AgenticaContext<Model>,
+  ) => Promise<AgenticaPrompt<Model>[]>;
 
   /* -----------------------------------------------------------
     CONSTRUCTOR
@@ -82,12 +87,12 @@ export class Agentica<Model extends ILlmSchema.Model> {
     this.prompt_histories_ = (props.histories ?? []).map((input) =>
       AgenticaPromptTransformer.transform({
         operations: this.operations_.group,
-        input,
+        prompt: input,
       }),
     );
 
     // STATUS
-    this.token_usage_ = AgenticaTokenUsageAggregator.zero();
+    this.token_usage_ = AgenticaTokenUsage.zero();
     this.ready_ = false;
     this.executor_ =
       typeof props.config?.executor === "function"
@@ -115,20 +120,27 @@ export class Agentica<Model extends ILlmSchema.Model> {
    *
    * When the user's conversation implies the A.I. chatbot to execute a
    * function calling, the returned chat prompts will contain the
-   * function calling information like {@link IAgenticaPrompt.IExecute}.
+   * function calling information like {@link IAgenticaPromptJson.IExecute}.
    *
    * @param content The content to talk
    * @returns List of newly created chat prompts
    */
-  public async conversate(content: string): Promise<IAgenticaPrompt<Model>[]> {
-    const prompt: IAgenticaPrompt.IText<"user"> = {
-      type: "text",
+  public async conversate(content: string): Promise<AgenticaPrompt<Model>[]> {
+    const prompt: AgenticaTextPrompt<"user"> = new AgenticaTextPrompt({
       role: "user",
       text: content,
-    };
-    await this.dispatch(prompt);
+    });
+    await this.dispatch(
+      new AgenticaTextEvent({
+        role: "user",
+        stream: StreamUtil.to(content),
+        done: () => true,
+        get: () => content,
+        join: () => Promise.resolve(content),
+      }),
+    );
 
-    const newbie: IAgenticaPrompt<Model>[] = await this.executor_(
+    const newbie: AgenticaPrompt<Model>[] = await this.executor_(
       this.getContext({
         prompt,
         usage: this.token_usage_,
@@ -170,7 +182,7 @@ export class Agentica<Model extends ILlmSchema.Model> {
    *
    * @returns
    */
-  public getOperations(): ReadonlyArray<IAgenticaOperation<Model>> {
+  public getOperations(): ReadonlyArray<AgenticaOperation<Model>> {
     return this.operations_.array;
   }
 
@@ -181,7 +193,7 @@ export class Agentica<Model extends ILlmSchema.Model> {
    *
    * @returns List of chat prompts
    */
-  public getPromptHistories(): IAgenticaPrompt<Model>[] {
+  public getPromptHistories(): AgenticaPrompt<Model>[] {
     return this.prompt_histories_;
   }
 
@@ -193,7 +205,7 @@ export class Agentica<Model extends ILlmSchema.Model> {
    *
    * @returns Cost of the A.I. chatbot
    */
-  public getTokenUsage(): IAgenticaTokenUsage {
+  public getTokenUsage(): AgenticaTokenUsage {
     return this.token_usage_;
   }
 
@@ -201,10 +213,10 @@ export class Agentica<Model extends ILlmSchema.Model> {
    * @internal
    */
   public getContext(props: {
-    prompt: IAgenticaPrompt.IText<"user">;
-    usage: IAgenticaTokenUsage;
-  }): IAgenticaContext<Model> {
-    const dispatch = (event: IAgenticaEvent<Model>) => this.dispatch(event);
+    prompt: AgenticaTextPrompt<"user">;
+    usage: AgenticaTokenUsage;
+  }): AgenticaContext<Model> {
+    const dispatch = (event: AgenticaEvent<Model>) => this.dispatch(event);
     return {
       // APPLICATION
       operations: this.operations_,
@@ -218,47 +230,65 @@ export class Agentica<Model extends ILlmSchema.Model> {
 
       // HANDLERS
       dispatch: (event) => this.dispatch(event),
-      request: async (kind, body) => {
+      request: async (source, body) => {
         // request information
-        const event: IAgenticaEvent.IRequest = {
-          type: "request",
-          source: kind,
+        const event: AgenticaRequestEvent = new AgenticaRequestEvent({
+          source,
           body: {
             ...body,
             model: this.props.vendor.model,
+            stream: true,
           },
           options: this.props.vendor.options,
-        };
+        });
         await dispatch(event);
 
         // completion
-        const completion: OpenAI.ChatCompletion =
-          await this.props.vendor.api.chat.completions.create(
-            event.body,
-            event.options,
-          );
+        const completion = await this.props.vendor.api.chat.completions.create(
+          event.body,
+          event.options,
+        );
+
+        const [streamForEvent, temporaryStream] = StreamUtil.transform(
+          completion.toReadableStream() as ReadableStream<Uint8Array>,
+          (value) =>
+            ChatGptCompletionMessageUtil.transformCompletionChunk(value),
+        ).tee();
+
+        const [streamForAggregate, streamForReturn] = temporaryStream.tee();
+
+        void (async () => {
+          const reader = streamForAggregate.getReader();
+          while (true) {
+            const chunk = await reader.read();
+            if (chunk.done) break;
+            if (chunk.value.usage) {
+              AgenticaTokenUsageAggregator.aggregate({
+                kind: source,
+                completionUsage: chunk.value.usage,
+                usage: props.usage,
+              });
+            }
+          }
+        })();
 
-        if (completion.usage) {
-          AgenticaTokenUsageAggregator.aggregate({
-            kind,
-            completionUsage: completion.usage,
-            usage: props.usage,
-          });
-        }
         await dispatch({
           type: "response",
-          source: kind,
+          source: source,
+          stream: streamForEvent,
           body: event.body,
           options: event.options,
-          value: completion,
+          join: async () => {
+            const chunks = await StreamUtil.readAll(streamForEvent);
+            return ChatGptCompletionMessageUtil.merge(chunks);
+          },
         });
-        return completion;
+
+        return streamForReturn;
       },
       initialize: async () => {
         this.ready_ = true;
-        await dispatch({
-          type: "initialize",
-        });
+        await dispatch(new AgenticaInitializeEvent());
       },
     };
   }
@@ -274,10 +304,10 @@ export class Agentica<Model extends ILlmSchema.Model> {
    * @param type Type of event
    * @param listener Callback function to be called whenever the event is emitted
    */
-  public on<Type extends IAgenticaEvent.Type>(
+  public on<Type extends AgenticaEvent.Type>(
     type: Type,
     listener: (
-      event: IAgenticaEvent.Mapper<Model>[Type],
+      event: AgenticaEvent.Mapper<Model>[Type],
     ) => void | Promise<void>,
   ): this {
     __map_take(this.listeners_, type, () => new Set()).add(listener);
@@ -292,10 +322,10 @@ export class Agentica<Model extends ILlmSchema.Model> {
    * @param type Type of event
    * @param listener Callback function to erase
    */
-  public off<Type extends IAgenticaEvent.Type>(
+  public off<Type extends AgenticaEvent.Type>(
     type: Type,
     listener: (
-      event: IAgenticaEvent.Mapper<Model>[Type],
+      event: AgenticaEvent.Mapper<Model>[Type],
     ) => void | Promise<void>,
   ): this {
     const set = this.listeners_.get(type);
@@ -306,7 +336,7 @@ export class Agentica<Model extends ILlmSchema.Model> {
     return this;
   }
 
-  private async dispatch<Event extends IAgenticaEvent<Model>>(
+  private async dispatch<Event extends AgenticaEvent<Model>>(
     event: Event,
   ): Promise<void> {
     const set = this.listeners_.get(event.type);

package/src/chatgpt/ChatGptAgent.ts

@@ -1,8 +1,9 @@
 import { ILlmSchema } from "@samchon/openapi";
 
-import { IAgenticaContext } from "../structures/IAgenticaContext";
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
+import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
 import { IAgenticaExecutor } from "../structures/IAgenticaExecutor";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
 import { ChatGptCallFunctionAgent } from "./ChatGptCallFunctionAgent";
 import { ChatGptCancelFunctionAgent } from "./ChatGptCancelFunctionAgent";
 import { ChatGptDescribeFunctionAgent } from "./ChatGptDescribeFunctionAgent";
@@ -14,8 +15,8 @@ export namespace ChatGptAgent {
     <Model extends ILlmSchema.Model>(
       executor: Partial<IAgenticaExecutor<Model>> | null,
     ) =>
-    async (ctx: IAgenticaContext<Model>): Promise<IAgenticaPrompt<Model>[]> => {
-      const histories: IAgenticaPrompt<Model>[] = [];
+    async (ctx: AgenticaContext<Model>): Promise<AgenticaPrompt<Model>[]> => {
+      const histories: AgenticaPrompt<Model>[] = [];
 
       // FUNCTIONS ARE NOT LISTED YET
       if (ctx.ready() === false) {
@@ -49,19 +50,19 @@ export namespace ChatGptAgent {
       // FUNCTION CALLING LOOP
       while (true) {
         // EXECUTE FUNCTIONS
-        const prompts: IAgenticaPrompt<Model>[] = await (
+        const prompts: AgenticaPrompt<Model>[] = await (
           executor?.call ?? ChatGptCallFunctionAgent.execute
         )(ctx);
         histories.push(...prompts);
 
         // EXPLAIN RETURN VALUES
-        const executes: IAgenticaPrompt.IExecute<Model>[] = prompts.filter(
+        const executes: AgenticaExecutePrompt<Model>[] = prompts.filter(
           (prompt) => prompt.type === "execute",
         );
         for (const e of executes)
           await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
             reason: "completed",
-            name: e.function.name,
+            name: e.operation.name,
           });
         histories.push(
           ...(await (

package/src/chatgpt/ChatGptCallFunctionAgent.ts

@@ -9,25 +9,33 @@ import {
 import OpenAI from "openai";
 import { IValidation } from "typia";
 
+import { AgenticaCancelPrompt } from "../context/AgenticaCancelPrompt";
+import { AgenticaContext } from "../context/AgenticaContext";
+import { AgenticaOperation } from "../context/AgenticaOperation";
+import { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
+import { AgenticaCallEvent } from "../events/AgenticaCallEvent";
+import { AgenticaCancelEvent } from "../events/AgenticaCancelEvent";
+import { AgenticaExecuteEvent } from "../events/AgenticaExecuteEvent";
+import { AgenticaTextEvent } from "../events/AgenticaTextEvent";
 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 { IAgenticaEvent } from "../structures/IAgenticaEvent";
-import { IAgenticaOperation } from "../structures/IAgenticaOperation";
-import { IAgenticaPrompt } from "../structures/IAgenticaPrompt";
+import { StreamUtil } from "../internal/StreamUtil";
+import { AgenticaExecutePrompt } from "../prompts/AgenticaExecutePrompt";
+import { AgenticaPrompt } from "../prompts/AgenticaPrompt";
+import { AgenticaTextPrompt } from "../prompts/AgenticaTextPrompt";
 import { ChatGptCancelFunctionAgent } from "./ChatGptCancelFunctionAgent";
+import { ChatGptCompletionMessageUtil } from "./ChatGptCompletionMessageUtil";
 import { ChatGptHistoryDecoder } from "./ChatGptHistoryDecoder";
 
 export namespace ChatGptCallFunctionAgent {
   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("call", {
+    const completionStream = await ctx.request("call", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -51,14 +59,14 @@ export namespace ChatGptCallFunctionAgent {
       ],
       // STACKED FUNCTIONS
       tools: ctx.stack.map(
-        (op) =>
+        (s) =>
           ({
             type: "function",
             function: {
-              name: op.name,
-              description: op.function.description,
-              parameters: (op.function.separated
-                ? (op.function.separated.llm ??
+              name: s.operation.name,
+              description: s.operation.function.description,
+              parameters: (s.operation.function.separated
+                ? (s.operation.function.separated.llm ??
                   ({
                     type: "object",
                     properties: {},
@@ -66,7 +74,7 @@ export namespace ChatGptCallFunctionAgent {
                     additionalProperties: false,
                     $defs: {},
                   } satisfies IChatGptSchema.IParameters))
-                : op.function.parameters) as Record<string, any>,
+                : s.operation.function.parameters) as Record<string, any>,
             },
           }) as OpenAI.ChatCompletionTool,
       ),
@@ -80,28 +88,31 @@ export namespace ChatGptCallFunctionAgent {
     const closures: Array<
       () => Promise<
         Array<
-          | IAgenticaPrompt.IExecute<Model>
-          | IAgenticaPrompt.ICancel<Model>
-          | IAgenticaPrompt.IText
+          | AgenticaExecutePrompt<Model>
+          | AgenticaCancelPrompt<Model>
+          | AgenticaTextPrompt
         >
       >
     > = [];
+
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
+
     for (const choice of completion.choices) {
       for (const tc of choice.message.tool_calls ?? []) {
         if (tc.type === "function") {
-          const operation: IAgenticaOperation<Model> | undefined =
+          const operation: AgenticaOperation<Model> | undefined =
             ctx.operations.flat.get(tc.function.name);
           if (operation === undefined) continue;
           closures.push(
             async (): Promise<
-              [IAgenticaPrompt.IExecute<Model>, IAgenticaPrompt.ICancel<Model>]
+              [AgenticaExecutePrompt<Model>, AgenticaCancelPrompt<Model>]
             > => {
-              const call: IAgenticaEvent.ICall<Model> = {
-                type: "call",
+              const call: AgenticaCallEvent<Model> = new AgenticaCallEvent({
                 id: tc.id,
                 operation,
                 arguments: JSON.parse(tc.function.arguments),
-              };
+              });
               if (call.operation.protocol === "http")
                 fillHttpArguments({
                   operation: call.operation,
@@ -109,40 +120,43 @@ export namespace ChatGptCallFunctionAgent {
                 });
               await ctx.dispatch(call);
 
-              const execute: IAgenticaPrompt.IExecute<Model> = await propagate(
+              const execute: AgenticaExecutePrompt<Model> = await propagate(
                 ctx,
                 call,
                 0,
               );
-              await ctx.dispatch({
-                type: "execute",
-                id: call.id,
-                operation: call.operation,
-                arguments: execute.arguments,
-                value: execute.value,
-              });
+              await ctx.dispatch(
+                new AgenticaExecuteEvent({
+                  id: call.id,
+                  operation: call.operation,
+                  arguments: execute.arguments,
+                  value: execute.value,
+                }),
+              );
 
               await ChatGptCancelFunctionAgent.cancelFunction(ctx, {
                 name: call.operation.name,
                 reason: "completed",
               });
-              await ctx.dispatch({
-                type: "cancel",
-                operation: call.operation,
-                reason: "complete",
-              });
+              await ctx.dispatch(
+                new AgenticaCancelEvent({
+                  selection: new AgenticaOperationSelection({
+                    operation: call.operation,
+                    reason: "complete",
+                  }),
+                }),
+              );
               return [
                 execute,
-                {
-                  type: "cancel",
+                new AgenticaCancelPrompt({
                   id: call.id,
-                  operations: [
-                    AgenticaPromptFactory.selection({
-                      ...call.operation,
+                  selections: [
+                    new AgenticaOperationSelection({
+                      operation: call.operation,
                       reason: "complete",
                     }),
                   ],
-                } satisfies IAgenticaPrompt.ICancel<Model>,
+                }),
               ] as const;
             },
           );
@@ -153,12 +167,19 @@ export namespace ChatGptCallFunctionAgent {
         !!choice.message.content?.length
       )
         closures.push(async () => {
-          const value: IAgenticaPrompt.IText = {
-            type: "text",
+          const value: AgenticaTextPrompt = new AgenticaTextPrompt({
             role: "assistant",
             text: choice.message.content!,
-          };
-          await ctx.dispatch(value);
+          });
+          await ctx.dispatch(
+            new AgenticaTextEvent({
+              role: "assistant",
+              get: () => value.text,
+              done: () => true,
+              stream: StreamUtil.to(value.text),
+              join: () => Promise.resolve(value.text),
+            }),
+          );
           return [value];
         });
     }
@@ -166,10 +187,10 @@ export namespace ChatGptCallFunctionAgent {
   };
 
   const propagate = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-    call: IAgenticaEvent.ICall<Model>,
+    ctx: AgenticaContext<Model>,
+    call: AgenticaCallEvent<Model>,
     retry: number,
-  ): Promise<IAgenticaPrompt.IExecute<Model>> => {
+  ): Promise<AgenticaExecutePrompt<Model>> => {
     if (call.operation.protocol === "http") {
       //----
       // HTTP PROTOCOL
@@ -182,7 +203,7 @@ export namespace ChatGptCallFunctionAgent {
         check.success === false &&
         retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)
       ) {
-        const trial: IAgenticaPrompt.IExecute<Model> | null = await correct(
+        const trial: AgenticaExecutePrompt<Model> | null = await correct(
           ctx,
           call,
           retry,
@@ -217,26 +238,18 @@ export namespace ChatGptCallFunctionAgent {
           (success === false
             ? await correct(ctx, call, retry, response.body)
             : null) ??
-          (await AgenticaPromptFactory.execute({
-            type: "execute",
-            protocol: "http",
-            controller: call.operation.controller,
-            function: call.operation.function,
+          new AgenticaExecutePrompt({
+            operation: call.operation,
             id: call.id,
-            name: call.operation.name,
             arguments: call.arguments,
             value: response,
-          }))
+          })
         );
       } catch (error) {
         // DISPATCH ERROR
-        return AgenticaPromptFactory.execute({
-          type: "execute",
-          protocol: "http",
-          controller: call.operation.controller,
-          function: call.operation.function,
+        return new AgenticaExecutePrompt({
+          operation: call.operation,
           id: call.id,
-          name: call.operation.name,
           arguments: call.arguments,
           value: {
             status: 500,
@@ -265,13 +278,9 @@ export namespace ChatGptCallFunctionAgent {
           (retry++ < (ctx.config?.retry ?? AgenticaConstant.RETRY)
             ? await correct(ctx, call, retry, check.errors)
             : null) ??
-          AgenticaPromptFactory.execute({
-            type: "execute",
-            protocol: "class",
-            controller: call.operation.controller,
-            function: call.operation.function,
+          new AgenticaExecutePrompt({
             id: call.id,
-            name: call.operation.name,
+            operation: call.operation,
             arguments: call.arguments,
             value: {
               name: "TypeGuardError",
@@ -292,24 +301,16 @@ export namespace ChatGptCallFunctionAgent {
             : await (call.operation.controller.execute as any)[
                 call.operation.function.name
               ](call.arguments);
-        return AgenticaPromptFactory.execute({
-          type: "execute",
-          protocol: "class",
-          controller: call.operation.controller,
-          function: call.operation.function,
+        return new AgenticaExecutePrompt({
           id: call.id,
-          name: call.operation.name,
+          operation: call.operation,
           arguments: call.arguments,
           value,
         });
       } catch (error) {
-        return AgenticaPromptFactory.execute({
-          type: "execute",
-          protocol: "class",
-          controller: call.operation.controller,
-          function: call.operation.function,
+        return new AgenticaExecutePrompt({
           id: call.id,
-          name: call.operation.name,
+          operation: call.operation,
           arguments: call.arguments,
           value:
             error instanceof Error
@@ -325,15 +326,15 @@ export namespace ChatGptCallFunctionAgent {
   };
 
   const correct = async <Model extends ILlmSchema.Model>(
-    ctx: IAgenticaContext<Model>,
-    call: IAgenticaEvent.ICall<Model>,
+    ctx: AgenticaContext<Model>,
+    call: AgenticaCallEvent<Model>,
     retry: number,
     error: unknown,
-  ): Promise<IAgenticaPrompt.IExecute<Model> | null> => {
+  ): Promise<AgenticaExecutePrompt<Model> | null> => {
     //----
     // EXECUTE CHATGPT API
     //----
-    const completion: OpenAI.ChatCompletion = await ctx.request("call", {
+    const completionStream = await ctx.request("call", {
       messages: [
         // COMMON SYSTEM PROMPT
         {
@@ -405,6 +406,8 @@ export namespace ChatGptCallFunctionAgent {
       parallel_tool_calls: false,
     });
 
+    const chunks = await StreamUtil.readAll(completionStream);
+    const completion = ChatGptCompletionMessageUtil.merge(chunks);
     //----
     // PROCESS COMPLETION
     //----
@@ -417,18 +420,17 @@ export namespace ChatGptCallFunctionAgent {
     if (toolCall === undefined) return null;
     return propagate(
       ctx,
-      {
+      new AgenticaCallEvent({
         id: toolCall.id,
-        type: "call",
         operation: call.operation,
         arguments: JSON.parse(toolCall.function.arguments),
-      },
+      }),
       retry,
     );
   };
 
   const fillHttpArguments = <Model extends ILlmSchema.Model>(props: {
-    operation: IAgenticaOperation<Model>;
+    operation: AgenticaOperation<Model>;
     arguments: object;
   }): void => {
     if (props.operation.protocol !== "http") return;