@agentica/core 0.27.2 → 0.28.0

package/src/orchestrate/execute.ts

@@ -1,8 +1,7 @@
 import type { ILlmSchema } from "@samchon/openapi";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
-import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
-import type { AgenticaHistory } from "../histories/AgenticaHistory";
+import type { AgenticaExecuteEvent } from "../events";
 import type { IAgenticaExecutor } from "../structures/IAgenticaExecutor";
 
 import { call } from "./call";
@@ -12,72 +11,53 @@ import { initialize } from "./initialize";
 import { select } from "./select";
 
 export function execute<Model extends ILlmSchema.Model>(executor: Partial<IAgenticaExecutor<Model>> | null) {
-  return async (ctx: AgenticaContext<Model>): Promise<AgenticaHistory<Model>[]> => {
-    const histories: AgenticaHistory<Model>[] = [];
-
+  return async (ctx: AgenticaContext<Model>): Promise<void> => {
     // FUNCTIONS ARE NOT LISTED YET
     if (ctx.ready() === false) {
       if (executor?.initialize !== true && typeof executor?.initialize !== "function") {
         await ctx.initialize();
       }
       else {
-        histories.push(
-          ...(await (
-            typeof executor?.initialize === "function"
-              ? executor.initialize
-              : initialize
-          )(ctx)),
-        );
+        await (
+          typeof executor?.initialize === "function"
+            ? executor.initialize
+            : initialize
+        )(ctx);
         if (ctx.ready() === false) {
-          return histories;
+          return;
         }
       }
     }
 
     // CANCEL CANDIDATE FUNCTIONS
     if (ctx.stack.length !== 0) {
-      histories.push(
-        ...(await (executor?.cancel ?? cancel)(
-          ctx,
-        )),
-      );
+      await (executor?.cancel ?? cancel)(ctx);
     }
 
     // SELECT CANDIDATE FUNCTIONS
-    histories.push(
-      ...(await (executor?.select ?? select)(
-        ctx,
-      )),
-    );
+    await (executor?.select ?? select)(ctx);
     if (ctx.stack.length === 0) {
-      return histories;
+      return;
     }
 
     // FUNCTION CALLING LOOP
     while (true) {
       // EXECUTE FUNCTIONS
-      const prompts: AgenticaHistory<Model>[] = await (
+      const executes: AgenticaExecuteEvent<Model>[] = await (
         executor?.call ?? call
       )(ctx, ctx.stack.map(s => s.operation));
-      histories.push(...prompts);
 
       // EXPLAIN RETURN VALUES
-      const executes: AgenticaExecuteHistory<Model>[] = prompts.filter(
-        prompt => prompt.type === "execute",
-      );
       if (executor?.describe !== null && executor?.describe !== false) {
-        histories.push(
-          ...(await (
-            typeof executor?.describe === "function"
-              ? executor.describe
-              : describe
-          )(ctx, executes)),
-        );
+        await (
+          typeof executor?.describe === "function"
+            ? executor.describe
+            : describe
+        )(ctx, executes);
       }
       if (executes.length === 0 || ctx.stack.length === 0) {
         break;
       }
     }
-    return histories;
   };
 }

package/src/orchestrate/initialize.ts

@@ -5,12 +5,12 @@ import typia from "typia";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { __IChatInitialApplication } from "../context/internal/__IChatInitialApplication";
-import type { AgenticaHistory } from "../histories/AgenticaHistory";
+import type { AgenticaAssistantMessageEvent } from "../events/AgenticaAssistantMessageEvent";
 
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
-import { creatAssistantEvent } from "../factory/events";
-import { createAssistantMessageHistory, decodeHistory, decodeUserMessageContent } from "../factory/histories";
+import { creatAssistantMessageEvent } from "../factory/events";
+import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { MPSC } from "../utils/MPSC";
 import { streamDefaultReaderToAsyncGenerator, StreamUtil } from "../utils/StreamUtil";
@@ -20,31 +20,31 @@ const FUNCTION: ILlmFunction<"chatgpt"> = typia.llm.application<
   "chatgpt"
 >().functions[0]!;
 
-export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<AgenticaHistory<Model>[]> {
+export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>): Promise<void> {
   // ----
   // EXECUTE CHATGPT API
   // ----
   const completionStream = await ctx.request("initialize", {
     messages: [
-        // COMMON SYSTEM PROMPT
-        {
-          role: "system",
-          content: AgenticaDefaultPrompt.write(ctx.config),
-        } satisfies OpenAI.ChatCompletionSystemMessageParam,
-        // PREVIOUS HISTORIES
-        ...ctx.histories.map(decodeHistory).flat(),
-        // USER INPUT
-        {
-          role: "user",
-          content: ctx.prompt.contents.map(decodeUserMessageContent),
-        },
-        {
-          // SYSTEM PROMPT
-          role: "system",
-          content:
-            ctx.config?.systemPrompt?.initialize?.(ctx.histories)
-            ?? AgenticaSystemPrompt.INITIALIZE,
-        },
+      // COMMON SYSTEM PROMPT
+      {
+        role: "system",
+        content: AgenticaDefaultPrompt.write(ctx.config),
+      } satisfies OpenAI.ChatCompletionSystemMessageParam,
+      // PREVIOUS HISTORIES
+      ...ctx.histories.map(decodeHistory).flat(),
+      // USER INPUT
+      {
+        role: "user",
+        content: ctx.prompt.contents.map(decodeUserMessageContent),
+      },
+      {
+        // SYSTEM PROMPT
+        role: "system",
+        content:
+          ctx.config?.systemPrompt?.initialize?.(ctx.histories)
+          ?? AgenticaSystemPrompt.INITIALIZE,
+      },
     ],
     // GETTER FUNCTION
     tools: [
@@ -106,17 +106,16 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
         };
         mpsc.produce(choice.delta.content);
 
-        ctx.dispatch(
-          creatAssistantEvent({
-            stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
-            done: () => mpsc.done(),
-            get: () => textContext[choice.index]!.content,
-            join: async () => {
-              await mpsc.waitClosed();
-              return textContext[choice.index]!.content;
-            },
-          }),
-        ).catch(() => {});
+        const event: AgenticaAssistantMessageEvent = creatAssistantMessageEvent({
+          stream: streamDefaultReaderToAsyncGenerator(mpsc.consumer.getReader()),
+          done: () => mpsc.done(),
+          get: () => textContext[choice.index]!.content,
+          join: async () => {
+            await mpsc.waitClosed();
+            return textContext[choice.index]!.content;
+          },
+        });
+        ctx.dispatch(event);
       }
     };
 
@@ -136,18 +135,6 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
   // ----
   // PROCESS COMPLETION
   // ----
-  const prompts: AgenticaHistory<Model>[] = [];
-  for (const choice of completion.choices) {
-    if (
-      choice.message.role === "assistant"
-      && choice.message.content != null
-      && choice.message.content.length !== 0
-    ) {
-      prompts.push(
-        createAssistantMessageHistory({ text: choice.message.content }),
-      );
-    }
-  }
   if (
     completion.choices.some(
       c =>
@@ -157,7 +144,7 @@ export async function initialize<Model extends ILlmSchema.Model>(ctx: AgenticaCo
             tc.type === "function" && tc.function.name === FUNCTION.name,
         ),
     )
-  ) { await ctx.initialize(); }
-
-  return prompts;
+  ) {
+    await ctx.initialize();
+  }
 }

package/src/orchestrate/internal/{cancelFunction.ts → cancelFunctionFromContext.ts}

@@ -3,6 +3,7 @@ import type { ILlmSchema } from "@samchon/openapi";
 import type { AgenticaContext } from "../../context/AgenticaContext";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
 import type { __IChatFunctionReference } from "../../context/internal/__IChatFunctionReference";
+import type { AgenticaCancelEvent } from "../../events";
 
 import { createCancelEvent } from "../../factory/events";
 import { createOperationSelection } from "../../factory/operations";
@@ -10,26 +11,25 @@ import { createOperationSelection } from "../../factory/operations";
 /**
  * @internal
  */
-export function cancelFunction<Model extends ILlmSchema.Model>(
+export function cancelFunctionFromContext<Model extends ILlmSchema.Model>(
   ctx: AgenticaContext<Model>,
   reference: __IChatFunctionReference,
-): AgenticaOperationSelection<Model> | null {
+): void {
   const index: number = ctx.stack.findIndex(
     item => item.operation.name === reference.name,
   );
   if (index === -1) {
-    return null;
+    return;
   }
 
   const item: AgenticaOperationSelection<Model> = ctx.stack[index]!;
   ctx.stack.splice(index, 1);
-  ctx.dispatch(
-    createCancelEvent({
-      selection: createOperationSelection({
-        operation: item.operation,
-        reason: reference.reason,
-      }),
+
+  const event: AgenticaCancelEvent<Model> = createCancelEvent({
+    selection: createOperationSelection({
+      operation: item.operation,
+      reason: reference.reason,
     }),
-  ).catch(() => {});
-  return item;
+  });
+  ctx.dispatch(event);
 }

package/src/orchestrate/internal/{selectFunction.ts → selectFunctionFromContext.ts}

@@ -4,6 +4,7 @@ import type { AgenticaContext } from "../../context/AgenticaContext";
 import type { AgenticaOperation } from "../../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../../context/AgenticaOperationSelection";
 import type { __IChatFunctionReference } from "../../context/internal/__IChatFunctionReference";
+import type { AgenticaSelectEvent } from "../../events/AgenticaSelectEvent";
 
 import { createSelectEvent } from "../../factory/events";
 import { createOperationSelection } from "../../factory/operations";
@@ -11,23 +12,27 @@ import { createOperationSelection } from "../../factory/operations";
 /**
  * @internal
  */
-export async function selectFunction<Model extends ILlmSchema.Model>(ctx: AgenticaContext<Model>, reference: __IChatFunctionReference): Promise<AgenticaOperation<Model> | null> {
+export function selectFunctionFromContext<
+  Model extends ILlmSchema.Model,
+>(
+  ctx: AgenticaContext<Model>,
+  reference: __IChatFunctionReference,
+): void {
   const operation: AgenticaOperation<Model> | undefined
-      = ctx.operations.flat.get(reference.name);
+    = ctx.operations.flat.get(reference.name);
   if (operation === undefined) {
-    return null;
+    return;
   }
 
   const selection: AgenticaOperationSelection<Model>
-      = createOperationSelection({
-        operation,
-        reason: reference.reason,
-      });
+    = createOperationSelection({
+      operation,
+      reason: reference.reason,
+    });
   ctx.stack.push(selection);
-  ctx.dispatch(
-    createSelectEvent({
-      selection,
-    }),
-  ).catch(() => {});
-  return operation;
+
+  const event: AgenticaSelectEvent<Model> = createSelectEvent({
+    selection,
+  });
+  ctx.dispatch(event);
 }