@agentica/core 0.27.3 → 0.29.0

package/src/orchestrate/call.ts

@@ -16,29 +16,25 @@ import {
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { MicroAgenticaContext } from "../context/MicroAgenticaContext";
+import type { AgenticaAssistantMessageEvent, AgenticaExecuteEvent } from "../events";
 import type { AgenticaCallEvent } from "../events/AgenticaCallEvent";
-import type { AgenticaAssistantMessageHistory } from "../histories/AgenticaAssistantMessageHistory";
-import type { AgenticaCancelHistory } from "../histories/AgenticaCancelHistory";
-import type { AgenticaExecuteHistory } from "../histories/AgenticaExecuteHistory";
-import type { AgenticaHistory } from "../histories/AgenticaHistory";
 import type { MicroAgenticaHistory } from "../histories/MicroAgenticaHistory";
 
 import { AgenticaConstant } from "../constants/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
 import { isAgenticaContext } from "../context/internal/isAgenticaContext";
-import { creatAssistantEvent, createCallEvent, createExecuteEvent, createValidateEvent } from "../factory/events";
-import { createAssistantMessageHistory, createCancelHistory, createExecuteHistory, decodeHistory, decodeUserMessageContent } from "../factory/histories";
-import { createOperationSelection } from "../factory/operations";
+import { creatAssistantMessageEvent, createCallEvent, createExecuteEvent, createValidateEvent } from "../factory/events";
+import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { StreamUtil, toAsyncGenerator } from "../utils/StreamUtil";
 
-import { cancelFunction } from "./internal/cancelFunction";
+import { cancelFunctionFromContext } from "./internal/cancelFunctionFromContext";
 
 export async function call<Model extends ILlmSchema.Model>(
   ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
   operations: AgenticaOperation<Model>[],
-): Promise<AgenticaHistory<Model>[]> {
+): Promise<AgenticaExecuteEvent<Model>[]> {
   // ----
   // EXECUTE CHATGPT API
   // ----
@@ -93,24 +89,15 @@ export async function call<Model extends ILlmSchema.Model>(
         }) as OpenAI.ChatCompletionTool,
     ),
     tool_choice: "auto",
-    parallel_tool_calls: false,
+    // parallel_tool_calls: false,
   });
 
   // ----
   // PROCESS COMPLETION
   // ----
-  const closures: Array<
-    () => Promise<
-      Array<
-        | AgenticaExecuteHistory<Model>
-        | AgenticaCancelHistory<Model>
-        | AgenticaAssistantMessageHistory
-      >
-    >
-  > = [];
-
   const chunks = await StreamUtil.readAll(completionStream);
   const completion = ChatGptCompletionMessageUtil.merge(chunks);
+  const executes: AgenticaExecuteEvent<Model>[] = [];
 
   for (const choice of completion.choices) {
     for (const tc of choice.message.tool_calls ?? []) {
@@ -120,59 +107,34 @@ export async function call<Model extends ILlmSchema.Model>(
         if (operation === undefined) {
           continue;
         }
-        closures.push(
-          async (): Promise<
-            Array<AgenticaExecuteHistory<Model> | AgenticaCancelHistory<Model>>
-          > => {
-            const call: AgenticaCallEvent<Model> = createCallEvent({
-              id: tc.id,
-              operation,
-              // @TODO add type assertion!
-              arguments: JSON.parse(tc.function.arguments) as Record<string, unknown>,
-            });
-            if (call.operation.protocol === "http") {
-              fillHttpArguments({
-                operation: call.operation,
-                arguments: call.arguments,
-              });
-            }
-            await ctx.dispatch(call);
-
-            const execute: AgenticaExecuteHistory<Model> = await propagate(
-              ctx,
-              call,
-              0,
-            );
-            ctx.dispatch(
-              createExecuteEvent({
-                id: call.id,
-                operation: call.operation,
-                arguments: execute.arguments,
-                value: execute.value,
-              }),
-            ).catch(() => {});
-
-            if (isAgenticaContext(ctx)) {
-              cancelFunction(ctx, {
-                name: call.operation.name,
-                reason: "completed",
-              });
-              return [
-                execute,
-                createCancelHistory({
-                  id: call.id,
-                  selections: [
-                    createOperationSelection({
-                      operation: call.operation,
-                      reason: "complete",
-                    }),
-                  ],
-                }),
-              ];
-            }
-            return [execute];
-          },
+        const call: AgenticaCallEvent<Model> = createCallEvent({
+          id: tc.id,
+          operation,
+          // @TODO add type assertion!
+          arguments: JSON.parse(tc.function.arguments) as Record<string, unknown>,
+        });
+        if (call.operation.protocol === "http") {
+          fillHttpArguments({
+            operation: call.operation,
+            arguments: call.arguments,
+          });
+        }
+        ctx.dispatch(call);
+
+        const exec: AgenticaExecuteEvent<Model> = await propagate(
+          ctx,
+          call,
+          0,
         );
+        ctx.dispatch(exec);
+        executes.push(exec);
+
+        if (isAgenticaContext(ctx)) {
+          cancelFunctionFromContext(ctx, {
+            name: call.operation.name,
+            reason: "completed",
+          });
+        }
       }
     }
     if (
@@ -180,30 +142,24 @@ export async function call<Model extends ILlmSchema.Model>(
       && choice.message.content != null
       && choice.message.content.length !== 0
     ) {
-      closures.push(async () => {
-        const value: AgenticaAssistantMessageHistory = createAssistantMessageHistory(
-          { text: choice.message.content! },
-        );
-        ctx.dispatch(
-          creatAssistantEvent({
-            get: () => value.text,
-            done: () => true,
-            stream: toAsyncGenerator(value.text),
-            join: async () => Promise.resolve(value.text),
-          }),
-        ).catch(() => {});
-        return [value];
+      const text: string = choice.message.content;
+      const event: AgenticaAssistantMessageEvent = creatAssistantMessageEvent({
+        get: () => text,
+        done: () => true,
+        stream: toAsyncGenerator(text),
+        join: async () => Promise.resolve(text),
       });
+      ctx.dispatch(event);
     }
   }
-  return (await Promise.all(closures.map(async fn => fn()))).flat();
+  return executes;
 }
 
 async function propagate<Model extends ILlmSchema.Model>(
   ctx: AgenticaContext<Model> | MicroAgenticaContext<Model>,
   call: AgenticaCallEvent<Model>,
   retry: number,
-): Promise<AgenticaExecuteHistory<Model>> {
+): Promise<AgenticaExecuteEvent<Model>> {
   switch (call.operation.protocol) {
     case "http": {
       return propagateHttp({ ctx, operation: call.operation, call, retry });
@@ -228,7 +184,7 @@ async function propagateHttp<Model extends ILlmSchema.Model>(
     call: AgenticaCallEvent<Model>;
     retry: number;
   },
-): Promise<AgenticaExecuteHistory<Model>> {
+): Promise<AgenticaExecuteEvent<Model>> {
   // ----
   // HTTP PROTOCOL
   // ----
@@ -243,10 +199,10 @@ async function propagateHttp<Model extends ILlmSchema.Model>(
         operation: props.operation,
         result: check,
       }),
-    ).catch(() => {});
+    );
 
     if (props.retry++ < (props.ctx.config?.retry ?? AgenticaConstant.RETRY)) {
-      const trial: AgenticaExecuteHistory<Model> | null = await correct(
+      const trial: AgenticaExecuteEvent<Model> | null = await correct(
         props.ctx,
         props.call,
         props.retry,
@@ -273,9 +229,8 @@ async function propagateHttp<Model extends ILlmSchema.Model>(
       (success === false
         ? await correct(props.ctx, props.call, props.retry, response.body)
         : null)
-      ?? createExecuteHistory({
+      ?? createExecuteEvent({
         operation: props.call.operation,
-        id: props.call.id,
         arguments: props.call.arguments,
         value: response,
       })
@@ -283,9 +238,8 @@ async function propagateHttp<Model extends ILlmSchema.Model>(
   }
   catch (error) {
     // DISPATCH ERROR
-    return createExecuteHistory({
+    return createExecuteEvent({
       operation: props.call.operation,
-      id: props.call.id,
       arguments: props.call.arguments,
       value: {
         status: 500,
@@ -308,7 +262,7 @@ async function propagateClass<Model extends ILlmSchema.Model>(props: {
   operation: AgenticaOperation.Class<Model>;
   call: AgenticaCallEvent<Model>;
   retry: number;
-}): Promise<AgenticaExecuteHistory<Model>> {
+}): Promise<AgenticaExecuteEvent<Model>> {
 // ----
   // CLASS FUNCTION
   // ----
@@ -323,13 +277,12 @@ async function propagateClass<Model extends ILlmSchema.Model>(props: {
         operation: props.call.operation,
         result: check,
       }),
-    ).catch(() => {});
+    );
     return (
       (props.retry++ < (props.ctx.config?.retry ?? AgenticaConstant.RETRY)
         ? await correct(props.ctx, props.call, props.retry, check.errors)
         : null)
-      ?? createExecuteHistory({
-        id: props.call.id,
+      ?? createExecuteEvent({
         operation: props.call.operation,
         arguments: props.call.arguments,
         value: {
@@ -343,16 +296,14 @@ async function propagateClass<Model extends ILlmSchema.Model>(props: {
   // EXECUTE FUNCTION
   try {
     const value = await executeClassOperation(props.operation, props.call.arguments);
-    return createExecuteHistory({
-      id: props.call.id,
+    return createExecuteEvent({
       operation: props.call.operation,
       arguments: props.call.arguments,
       value,
     });
   }
   catch (error) {
-    return createExecuteHistory({
-      id: props.call.id,
+    return createExecuteEvent({
       operation: props.call.operation,
       arguments: props.call.arguments,
       value:
@@ -372,23 +323,21 @@ async function propagateMcp<Model extends ILlmSchema.Model>(props: {
   operation: AgenticaOperation.Mcp<Model>;
   call: AgenticaCallEvent<Model>;
   retry: number;
-}): Promise<AgenticaExecuteHistory<Model>> {
+}): Promise<AgenticaExecuteEvent<Model>> {
   // ----
   // MCP PROTOCOL
   // ----
   // @TODO: implement argument validation logic
   try {
     const value = await executeMcpOperation(props.operation, props.call.arguments);
-    return createExecuteHistory({
-      id: props.call.id,
+    return createExecuteEvent({
       operation: props.call.operation,
       arguments: props.call.arguments,
       value,
     });
   }
   catch (error) {
-    return createExecuteHistory({
-      id: props.call.id,
+    return createExecuteEvent({
       operation: props.call.operation,
       arguments: props.call.arguments,
       value:
@@ -454,7 +403,7 @@ async function correct<Model extends ILlmSchema.Model>(
   call: AgenticaCallEvent<Model>,
   retry: number,
   error: unknown,
-): Promise<AgenticaExecuteHistory<Model> | null> {
+): Promise<AgenticaExecuteEvent<Model> | null> {
   // ----
   // EXECUTE CHATGPT API
   // ----
@@ -544,11 +493,12 @@ async function correct<Model extends ILlmSchema.Model>(
         name: call.operation.name,
       },
     },
-    parallel_tool_calls: false,
+    // parallel_tool_calls: false,
   });
 
   const chunks = await StreamUtil.readAll(completionStream);
   const completion = ChatGptCompletionMessageUtil.merge(chunks);
+
   // ----
   // PROCESS COMPLETION
   // ----

package/src/orchestrate/cancel.ts

@@ -3,24 +3,23 @@ import type OpenAI from "openai";
 import type { IValidation } from "typia";
 
 import typia from "typia";
-import { v4 } from "uuid";
 
 import type { AgenticaContext } from "../context/AgenticaContext";
 import type { AgenticaOperation } from "../context/AgenticaOperation";
 import type { AgenticaOperationSelection } from "../context/AgenticaOperationSelection";
 import type { __IChatCancelFunctionsApplication } from "../context/internal/__IChatCancelFunctionsApplication";
 import type { __IChatFunctionReference } from "../context/internal/__IChatFunctionReference";
+import type { AgenticaCancelEvent } from "../events/AgenticaCancelEvent";
 import type { AgenticaEvent } from "../events/AgenticaEvent";
-import type { AgenticaCancelHistory } from "../histories/AgenticaCancelHistory";
 
 import { AgenticaConstant } from "../constants/AgenticaConstant";
 import { AgenticaDefaultPrompt } from "../constants/AgenticaDefaultPrompt";
 import { AgenticaSystemPrompt } from "../constants/AgenticaSystemPrompt";
-import { createCancelHistory, decodeHistory, decodeUserMessageContent } from "../factory/histories";
+import { decodeHistory, decodeUserMessageContent } from "../factory/histories";
 import { ChatGptCompletionMessageUtil } from "../utils/ChatGptCompletionMessageUtil";
 import { StreamUtil } from "../utils/StreamUtil";
 
-import { cancelFunction } from "./internal/cancelFunction";
+import { cancelFunctionFromContext } from "./internal/cancelFunctionFromContext";
 
 const CONTAINER: ILlmApplication<"chatgpt"> = typia.llm.application<
   __IChatCancelFunctionsApplication,
@@ -35,7 +34,7 @@ interface IFailure {
 
 export async function cancel<Model extends ILlmSchema.Model>(
   ctx: AgenticaContext<Model>,
-): Promise<AgenticaCancelHistory<Model>[]> {
+): Promise<void> {
   if (ctx.operations.divided === undefined) {
     return step(ctx, ctx.operations.array, 0);
   }
@@ -43,14 +42,15 @@ export async function cancel<Model extends ILlmSchema.Model>(
   const stacks: AgenticaOperationSelection<Model>[][]
       = ctx.operations.divided.map(() => []);
   const events: AgenticaEvent<Model>[] = [];
-  const prompts: AgenticaCancelHistory<Model>[][] = await Promise.all(
+  await Promise.all(
     ctx.operations.divided.map(async (operations, i) =>
       step(
         {
           ...ctx,
           stack: stacks[i]!,
-          dispatch: async (e) => {
+          dispatch: (e) => {
             events.push(e);
+            return e;
           },
         },
         operations,
@@ -59,12 +59,11 @@ export async function cancel<Model extends ILlmSchema.Model>(
     ),
   );
 
-  // NO FUNCTION SELECTION, SO THAT ONLY TEXT LEFT
-  if (stacks.every(s => s.length === 0)) {
-    return prompts[0]!;
-  }
   // ELITICISM
-  else if ((ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true) {
+  if (
+    (ctx.config?.eliticism ?? AgenticaConstant.ELITICISM) === true
+    && stacks.some(s => s.length !== 0)
+  ) {
     return step(
       ctx,
       stacks
@@ -78,22 +77,12 @@ export async function cancel<Model extends ILlmSchema.Model>(
       0,
     );
   }
-
-  // RE-COLLECT SELECT FUNCTION EVENTS
-  const collection: AgenticaCancelHistory<Model> = createCancelHistory({
-    id: v4(),
-    selections: [],
-  });
-  for (const e of events) {
-    if (e.type === "select") {
-      collection.selections.push(e.selection);
-      cancelFunction(ctx, {
-        name: e.selection.operation.name,
-        reason: e.selection.reason,
-      });
-    }
+  else {
+    const cancelled: AgenticaCancelEvent<Model>[]
+        = events.filter(e => e.type === "cancel");
+    (cancelled.length !== 0 ? cancelled : events)
+      .forEach(ctx.dispatch);
   }
-  return [collection];
 }
 
 async function step<Model extends ILlmSchema.Model>(
@@ -101,64 +90,64 @@ async function step<Model extends ILlmSchema.Model>(
   operations: AgenticaOperation<Model>[],
   retry: number,
   failures?: IFailure[],
-): Promise<AgenticaCancelHistory<Model>[]> {
+): Promise<void> {
   // ----
   // EXECUTE CHATGPT API
   // ----
   const completionStream = await ctx.request("cancel", {
     messages: [
-        // COMMON SYSTEM PROMPT
-        {
-          role: "system",
-          content: AgenticaDefaultPrompt.write(ctx.config),
-        } satisfies OpenAI.ChatCompletionSystemMessageParam,
-        // CANDIDATE FUNCTIONS
-        {
-          role: "assistant",
-          tool_calls: [
-            {
-              type: "function",
-              id: "getApiFunctions",
-              function: {
-                name: "getApiFunctions",
-                arguments: JSON.stringify({}),
-              },
+      // COMMON SYSTEM PROMPT
+      {
+        role: "system",
+        content: AgenticaDefaultPrompt.write(ctx.config),
+      } satisfies OpenAI.ChatCompletionSystemMessageParam,
+      // CANDIDATE FUNCTIONS
+      {
+        role: "assistant",
+        tool_calls: [
+          {
+            type: "function",
+            id: "getApiFunctions",
+            function: {
+              name: "getApiFunctions",
+              arguments: JSON.stringify({}),
             },
-          ],
-        },
-        {
-          role: "tool",
-          tool_call_id: "getApiFunctions",
-          content: JSON.stringify(
-            operations.map(op => ({
-              name: op.name,
-              description: op.function.description,
-              ...(op.protocol === "http"
-                ? {
-                    method: op.function.method,
-                    path: op.function.path,
-                    tags: op.function.tags,
-                  }
-                : {}),
-            })),
-          ),
-        },
-        // 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?.cancel?.(ctx.histories)
-            ?? AgenticaSystemPrompt.CANCEL,
-        },
-        // TYPE CORRECTIONS
-        ...emendMessages(failures ?? []),
+          },
+        ],
+      },
+      {
+        role: "tool",
+        tool_call_id: "getApiFunctions",
+        content: JSON.stringify(
+          operations.map(op => ({
+            name: op.name,
+            description: op.function.description,
+            ...(op.protocol === "http"
+              ? {
+                  method: op.function.method,
+                  path: op.function.path,
+                  tags: op.function.tags,
+                }
+              : {}),
+          })),
+        ),
+      },
+      // 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?.cancel?.(ctx.histories)
+          ?? AgenticaSystemPrompt.CANCEL,
+      },
+      // TYPE CORRECTIONS
+      ...emendMessages(failures ?? []),
     ],
     // STACK FUNCTIONS
     tools: [{
@@ -183,7 +172,7 @@ async function step<Model extends ILlmSchema.Model>(
             name: CONTAINER.functions[0]!.name,
           },
         },
-    parallel_tool_calls: true,
+    // parallel_tool_calls: true,
   });
 
   const chunks = await StreamUtil.readAll(completionStream);
@@ -200,9 +189,9 @@ async function step<Model extends ILlmSchema.Model>(
           continue;
         }
 
-        const input = JSON.parse(tc.function.arguments) as object;
+        const input: object = JSON.parse(tc.function.arguments) as object;
         const validation: IValidation<__IChatFunctionReference.IProps>
-            = typia.validate<__IChatFunctionReference.IProps>(input);
+          = typia.validate<__IChatFunctionReference.IProps>(input);
         if (validation.success === false) {
           failures.push({
             id: tc.id,
@@ -220,7 +209,6 @@ async function step<Model extends ILlmSchema.Model>(
   // ----
   // PROCESS COMPLETION
   // ----
-  const prompts: AgenticaCancelHistory<Model>[] = [];
   for (const choice of completion.choices) {
     // TOOL CALLING HANDLER
     if (choice.message.tool_calls != null) {
@@ -228,35 +216,24 @@ async function step<Model extends ILlmSchema.Model>(
         if (tc.type !== "function") {
           continue;
         }
-
-        if (tc.function.name !== "cancelFunctions") {
+        else if (tc.function.name !== "cancelFunctions") {
           continue;
         }
 
-        const input = typia.json.isParse<__IChatFunctionReference.IProps>(tc.function.arguments);
+        const input: __IChatFunctionReference.IProps | null
+          = typia.json.isParse<
+            __IChatFunctionReference.IProps
+          >(tc.function.arguments);
         if (input === null) {
           continue;
         }
 
-        const collection: AgenticaCancelHistory<Model> = createCancelHistory({
-          id: tc.id,
-          selections: [],
-        });
-
         for (const reference of input.functions) {
-          const operation = cancelFunction(ctx, reference);
-          if (operation !== null) {
-            collection.selections.push(operation);
-          }
-        }
-
-        if (collection.selections.length !== 0) {
-          prompts.push(collection);
+          cancelFunctionFromContext(ctx, reference);
         }
       }
     }
   }
-  return prompts;
 }
 
 function emendMessages(failures: IFailure[]): OpenAI.ChatCompletionMessageParam[] {